[INFO] fetching crate rust_swig 0.5.1... [INFO] linting rust_swig-0.5.1 against nightly for clippy-nonminimal_bool-denied [INFO] extracting crate rust_swig 0.5.1 into /workspace/builds/worker-1-tc1/source [INFO] started tweaking crates.io crate rust_swig 0.5.1 [INFO] finished tweaking crates.io crate rust_swig 0.5.1 [INFO] tweaked toml for crates.io crate rust_swig 0.5.1 written to /workspace/builds/worker-1-tc1/source/Cargo.toml [INFO] validating manifest of crates.io crate rust_swig 0.5.1 on toolchain nightly [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+nightly" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+nightly" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 83 packages to latest compatible versions [INFO] [stderr] Adding bitflags v1.3.2 (available: v2.11.0) [INFO] [stderr] Adding env_logger v0.7.1 (available: v0.11.9) [INFO] [stderr] Adding heck v0.3.3 (available: v0.5.0) [INFO] [stderr] Adding jni-sys v0.3.0 (available: v0.4.1) [INFO] [stderr] Adding petgraph v0.5.1 (available: v0.8.3) [INFO] [stderr] Adding pulldown-cmark v0.7.2 (available: v0.13.1) [INFO] [stderr] Adding rustc-hash v1.1.0 (available: v2.1.1) [INFO] [stderr] Adding smol_str v0.1.24 (available: v0.3.6) [INFO] [stderr] Adding strum v0.18.0 (available: v0.28.0) [INFO] [stderr] Adding syn v1.0.109 (available: v2.0.117) [INFO] [stderr] Adding which v3.1.1 (available: v8.0.2) [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+nightly" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Downloading crates ... [INFO] [stderr] Downloaded smol_str v0.1.24 [INFO] [stderr] Downloaded strum_macros v0.18.0 [INFO] [stderr] Downloaded pulldown-cmark v0.7.2 [INFO] [stderr] Downloaded strum v0.18.0 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+nightly" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] 256c8f07416372c78778eec887fba7209befd9f6dc304be9807a95bfdfdcc2e6 [INFO] running `Command { std: "docker" "start" "-a" "256c8f07416372c78778eec887fba7209befd9f6dc304be9807a95bfdfdcc2e6", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "256c8f07416372c78778eec887fba7209befd9f6dc304be9807a95bfdfdcc2e6", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "256c8f07416372c78778eec887fba7209befd9f6dc304be9807a95bfdfdcc2e6", kill_on_drop: false }` [INFO] [stdout] 256c8f07416372c78778eec887fba7209befd9f6dc304be9807a95bfdfdcc2e6 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+nightly" "clippy" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 34c3619d455c577172f1ab3585c22f0c4f394d2a8ed0de779c6a5318347f17e6 [INFO] running `Command { std: "docker" "start" "-a" "34c3619d455c577172f1ab3585c22f0c4f394d2a8ed0de779c6a5318347f17e6", kill_on_drop: false }` [INFO] [stderr] Compiling syn v1.0.109 [INFO] [stderr] Compiling serde v1.0.228 [INFO] [stderr] Compiling pulldown-cmark v0.7.2 [INFO] [stderr] Checking fixedbitset v0.2.0 [INFO] [stderr] Checking which v3.1.1 [INFO] [stderr] Checking heck v0.3.3 [INFO] [stderr] Checking once_cell v1.21.4 [INFO] [stderr] Checking env_logger v0.7.1 [INFO] [stderr] Checking jni-sys v0.3.0 [INFO] [stderr] Checking tempfile v3.27.0 [INFO] [stderr] Checking petgraph v0.5.1 [INFO] [stderr] Checking smol_str v0.1.24 [INFO] [stderr] Compiling rust_swig v0.5.1 (/opt/rustwide/workdir) [INFO] [stderr] Compiling strum_macros v0.18.0 [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/file_cache.rs:59:9 [INFO] [stdout] | [INFO] [stdout] 59 | ::std::mem::replace(&mut self.cnt, vec![]) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut self.cnt)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] = note: `#[warn(clippy::mem_replace_with_default)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: function call inside of `expect` [INFO] [stdout] --> build.rs:42:14 [INFO] [stdout] | [INFO] [stdout] 42 | .expect(&format!("Error during read {}", include_path.display())); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| panic!("Error during read {}", include_path.display()))` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call [INFO] [stdout] = note: `#[warn(clippy::expect_fun_call)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: function call inside of `expect` [INFO] [stdout] --> build.rs:53:14 [INFO] [stdout] | [INFO] [stdout] 53 | .expect(&format!("Error during parse {}", include_path.display())); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| panic!("Error during parse {}", include_path.display()))` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `to_string` applied to a type that implements `Display` in `write!` args [INFO] [stdout] --> build.rs:74:58 [INFO] [stdout] | [INFO] [stdout] 74 | write!(&mut cache, "{}", file.into_token_stream().to_string()).expect(&write_err_msg); [INFO] [stdout] | ^^^^^^^^^^^^ help: remove this [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args [INFO] [stdout] = note: `#[warn(clippy::to_string_in_format_args)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Checking strum v0.18.0 [INFO] [stdout] warning: method `name` is never used [INFO] [stdout] --> src/typemap/utils.rs:26:8 [INFO] [stdout] | [INFO] [stdout] 25 | pub(crate) trait ForeignTypeInfoT { [INFO] [stdout] | ---------------- method in this trait [INFO] [stdout] 26 | fn name(&self) -> &str; [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: method `output` is never used [INFO] [stdout] --> src/typemap/utils.rs:41:8 [INFO] [stdout] | [INFO] [stdout] 39 | pub(crate) trait ForeignMethodSignature { [INFO] [stdout] | ---------------------- method in this trait [INFO] [stdout] 40 | type FI: ForeignTypeInfoT; [INFO] [stdout] 41 | fn output(&self) -> &dyn ForeignTypeInfoT; [INFO] [stdout] | ^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: field `span` is never read [INFO] [stdout] --> src/types.rs:126:16 [INFO] [stdout] | [INFO] [stdout] 125 | pub(crate) struct FnDecl { [INFO] [stdout] | ------ field in this struct [INFO] [stdout] 126 | pub(crate) span: Span, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `FnDecl` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/code_parse.rs:180:21 [INFO] [stdout] | [INFO] [stdout] 180 | } = parse_attrs(&input, true)?; [INFO] [stdout] | ^^^^^^ help: change this to: `input` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] = note: `#[warn(clippy::needless_borrow)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/code_parse.rs:204:47 [INFO] [stdout] | [INFO] [stdout] 204 | let doc_comments = parse_doc_comments(&&content)?; [INFO] [stdout] | ^^^^^^^^^ help: change this to: `&content` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent [INFO] [stdout] --> src/code_parse.rs:353:63 [INFO] [stdout] | [INFO] [stdout] 353 | MethodVariant::Method(ref mut self_type) => match args_in.iter().nth(0) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ help: try calling `.next()` instead of `.nth(0)`: `args_in.iter().next()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero [INFO] [stdout] = note: `#[warn(clippy::iter_nth_zero)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/code_parse.rs:437:75 [INFO] [stdout] | [INFO] [stdout] 437 | if normalize_type(constructor_ret_type) != normalize_type(&*ret_type) { [INFO] [stdout] | ^^^^^^^^^^ help: try: `&ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] = note: `#[warn(clippy::explicit_auto_deref)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: match expression looks like `matches!` macro [INFO] [stdout] --> src/code_parse.rs:713:34 [INFO] [stdout] | [INFO] [stdout] 713 | let have_self_args = match args_in.iter().nth(0) { [INFO] [stdout] | __________________________________^ [INFO] [stdout] 714 | | Some(syn::FnArg::Receiver(_)) => true, [INFO] [stdout] 715 | | _ => false, [INFO] [stdout] 716 | | }; [INFO] [stdout] | |_____________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] = note: `#[warn(clippy::match_like_matches_macro)]` on by default [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 713 - let have_self_args = match args_in.iter().nth(0) { [INFO] [stdout] 714 - Some(syn::FnArg::Receiver(_)) => true, [INFO] [stdout] 715 - _ => false, [INFO] [stdout] 716 - }; [INFO] [stdout] 713 + let have_self_args = matches!(args_in.iter().nth(0), Some(syn::FnArg::Receiver(_))); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:111:48 [INFO] [stdout] | [INFO] [stdout] 111 | let var_name = new_unique_name(&known_names, &templ); [INFO] [stdout] | ^^^^^^^^^^^^ help: change this to: `known_names` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:122:52 [INFO] [stdout] | [INFO] [stdout] 122 | ... Some(Cow::Borrowed(&arg_name)) [INFO] [stdout] | ^^^^^^^^^ help: change this to: `arg_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:139:60 [INFO] [stdout] | [INFO] [stdout] 139 | ... let tmp_name = new_unique_name(&known_names, name_template); [INFO] [stdout] | ^^^^^^^^^^^^ help: change this to: `known_names` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: explicit call to `.into_iter()` in function argument accepting `IntoIterator` [INFO] [stdout] --> src/cpp/cpp_code.rs:176:29 [INFO] [stdout] | [INFO] [stdout] 176 | includes.extend(mem::replace(&mut p.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()` [INFO] [stdout] --> /rustc/3645249d79dfb136b5d8de3ce153d19d6698d92d/library/core/src/iter/traits/collect.rs:416:17 [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion [INFO] [stdout] = note: `#[warn(clippy::useless_conversion)]` on by default [INFO] [stdout] help: consider removing the `.into_iter()` [INFO] [stdout] | [INFO] [stdout] 176 - includes.extend(mem::replace(&mut p.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] 176 + includes.extend(mem::replace(&mut p.provides_by_module, Vec::new())); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/cpp/cpp_code.rs:176:29 [INFO] [stdout] | [INFO] [stdout] 176 | includes.extend(mem::replace(&mut p.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut p.provides_by_module)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] = note: `#[warn(clippy::mem_replace_with_default)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: explicit call to `.into_iter()` in function argument accepting `IntoIterator` [INFO] [stdout] --> src/cpp/cpp_code.rs:178:25 [INFO] [stdout] | [INFO] [stdout] 178 | includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()` [INFO] [stdout] --> /rustc/3645249d79dfb136b5d8de3ce153d19d6698d92d/library/core/src/iter/traits/collect.rs:416:17 [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion [INFO] [stdout] help: consider removing the `.into_iter()` [INFO] [stdout] | [INFO] [stdout] 178 - includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] 178 + includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new())); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/cpp/cpp_code.rs:178:25 [INFO] [stdout] | [INFO] [stdout] 178 | includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut m.output.provides_by_module)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:241:45 [INFO] [stdout] | [INFO] [stdout] 241 | syn::Fields::Named(ref x) => Ok(&x), [INFO] [stdout] | ^^ help: change this to: `x` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: match expression looks like `matches!` macro [INFO] [stdout] --> src/cpp/fclass.rs:39:52 [INFO] [stdout] | [INFO] [stdout] 39 | let has_methods = class.methods.iter().any(|m| match m.variant { [INFO] [stdout] | ____________________________________________________^ [INFO] [stdout] 40 | | MethodVariant::Method(_) => true, [INFO] [stdout] 41 | | _ => false, [INFO] [stdout] 42 | | }); [INFO] [stdout] | |_____^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 39 - let has_methods = class.methods.iter().any(|m| match m.variant { [INFO] [stdout] 40 - MethodVariant::Method(_) => true, [INFO] [stdout] 41 - _ => false, [INFO] [stdout] 42 - }); [INFO] [stdout] 39 + let has_methods = class.methods.iter().any(|m| matches!(m.variant, MethodVariant::Method(_))); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:738:9 [INFO] [stdout] | [INFO] [stdout] 738 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:746:9 [INFO] [stdout] | [INFO] [stdout] 746 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:796:9 [INFO] [stdout] | [INFO] [stdout] 796 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:804:9 [INFO] [stdout] | [INFO] [stdout] 804 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:821:9 [INFO] [stdout] | [INFO] [stdout] 821 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:877:9 [INFO] [stdout] | [INFO] [stdout] 877 | &ret_type_name, [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `ret_type_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:885:9 [INFO] [stdout] | [INFO] [stdout] 885 | &ret_type_name, [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `ret_type_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this function has too many arguments (9/7) [INFO] [stdout] --> src/cpp/fclass.rs:1022:1 [INFO] [stdout] | [INFO] [stdout] 1022 | / fn generate_cpp_header_preamble( [INFO] [stdout] 1023 | | ctx: &mut CppContext, [INFO] [stdout] 1024 | | class: &ForeignerClassInfo, [INFO] [stdout] 1025 | | tmp_class_name: &str, [INFO] [stdout] ... | [INFO] [stdout] 1031 | | cpp_include_f: &mut FileWriteCache, [INFO] [stdout] 1032 | | ) -> Result<()> { [INFO] [stdout] | |_______________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stdout] = note: `#[warn(clippy::too_many_arguments)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/cpp/fenum.rs:20:48 [INFO] [stdout] | [INFO] [stdout] 20 | if (fenum.items.len() as u64) >= u64::from(u32::max_value()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] = note: `#[warn(clippy::legacy_numeric_constants)]` on by default [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 20 - if (fenum.items.len() as u64) >= u64::from(u32::max_value()) { [INFO] [stdout] 20 + if (fenum.items.len() as u64) >= u64::from(u32::MAX) { [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/cpp/fenum.rs:136:57 [INFO] [stdout] | [INFO] [stdout] 136 | assert!((enum_info.items.len() as u64) <= u64::from(u32::max_value())); [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 136 - assert!((enum_info.items.len() as u64) <= u64::from(u32::max_value())); [INFO] [stdout] 136 + assert!((enum_info.items.len() as u64) <= u64::from(u32::MAX)); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this function has too many arguments (8/7) [INFO] [stdout] --> src/cpp/map_class_self_type.rs:126:1 [INFO] [stdout] | [INFO] [stdout] 126 | / fn register_rust_ty_conversation_rules( [INFO] [stdout] 127 | | conv_map: &mut TypeMap, [INFO] [stdout] 128 | | class: &ForeignerClassInfo, [INFO] [stdout] 129 | | this_type: RustType, [INFO] [stdout] ... | [INFO] [stdout] 134 | | this_type_mut_ref: RustTypeIdx, [INFO] [stdout] 135 | | ) -> Result<()> { [INFO] [stdout] | |_______________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this function has too many arguments (8/7) [INFO] [stdout] --> src/cpp/map_class_self_type.rs:245:1 [INFO] [stdout] | [INFO] [stdout] 245 | / fn register_main_foreign_types( [INFO] [stdout] 246 | | conv_map: &mut TypeMap, [INFO] [stdout] 247 | | class: &ForeignerClassInfo, [INFO] [stdout] 248 | | this_type: RustTypeIdx, [INFO] [stdout] ... | [INFO] [stdout] 253 | | this_type_mut_ref: RustTypeIdx, [INFO] [stdout] 254 | | ) -> Result<()> { [INFO] [stdout] | |_______________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/cpp/mod.rs:498:19 [INFO] [stdout] | [INFO] [stdout] 498 | let f_codes = mem::replace(&mut rule.f_code, vec![]); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut rule.f_code)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/error.rs:105:31 [INFO] [stdout] | [INFO] [stdout] 105 | code_problem.push_str(&line); [INFO] [stdout] | ^^^^^ help: change this to: `line` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/file_cache.rs:59:9 [INFO] [stdout] | [INFO] [stdout] 59 | ::std::mem::replace(&mut self.cnt, vec![]) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut self.cnt)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.as_ref().map(String::as_str)` on an `Option` value [INFO] [stdout] --> src/java_jni/fclass.rs:47:9 [INFO] [stdout] | [INFO] [stdout] 47 | ctx.cfg.null_annotation_package.as_ref().map(String::as_str), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `ctx.cfg.null_annotation_package.as_deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref [INFO] [stdout] = note: `#[warn(clippy::option_as_ref_deref)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:192:43 [INFO] [stdout] | [INFO] [stdout] 192 | .replace(TO_VAR_TEMPLATE, &conv_ret); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `conv_ret` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/java_jni/fclass.rs:668:64 [INFO] [stdout] | [INFO] [stdout] 668 | syn::ReturnType::Type(_, ref ty) => normalize_type(&*ty), [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] = note: `#[warn(clippy::borrow_deref_ref)]` on by default [INFO] [stdout] help: if you would like to reborrow, try removing `&*` [INFO] [stdout] | [INFO] [stdout] 668 - syn::ReturnType::Type(_, ref ty) => normalize_type(&*ty), [INFO] [stdout] 668 + syn::ReturnType::Type(_, ref ty) => normalize_type(ty), [INFO] [stdout] | [INFO] [stdout] help: if you would like to deref, try using `&**` [INFO] [stdout] | [INFO] [stdout] 668 | syn::ReturnType::Type(_, ref ty) => normalize_type(&**ty), [INFO] [stdout] | + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:677:35 [INFO] [stdout] | [INFO] [stdout] 677 | real_output_typename: &real_output_typename, [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `real_output_typename` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: method `name` is never used [INFO] [stdout] --> src/typemap/utils.rs:26:8 [INFO] [stdout] | [INFO] [stdout] 25 | pub(crate) trait ForeignTypeInfoT { [INFO] [stdout] | ---------------- method in this trait [INFO] [stdout] 26 | fn name(&self) -> &str; [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: method `output` is never used [INFO] [stdout] --> src/typemap/utils.rs:41:8 [INFO] [stdout] | [INFO] [stdout] 39 | pub(crate) trait ForeignMethodSignature { [INFO] [stdout] | ---------------------- method in this trait [INFO] [stdout] 40 | type FI: ForeignTypeInfoT; [INFO] [stdout] 41 | fn output(&self) -> &dyn ForeignTypeInfoT; [INFO] [stdout] | ^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: field `span` is never read [INFO] [stdout] --> src/types.rs:126:16 [INFO] [stdout] | [INFO] [stdout] 125 | pub(crate) struct FnDecl { [INFO] [stdout] | ------ field in this struct [INFO] [stdout] 126 | pub(crate) span: Span, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `FnDecl` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:857:9 [INFO] [stdout] | [INFO] [stdout] 857 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:866:9 [INFO] [stdout] | [INFO] [stdout] 866 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:981:9 [INFO] [stdout] | [INFO] [stdout] 981 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:990:9 [INFO] [stdout] | [INFO] [stdout] 990 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/java_jni/fenum.rs:31:39 [INFO] [stdout] | [INFO] [stdout] 31 | if (fenum.items.len() as u64) >= (i32::max_value() as u64) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 31 - if (fenum.items.len() as u64) >= (i32::max_value() as u64) { [INFO] [stdout] 31 + if (fenum.items.len() as u64) >= (i32::MAX as u64) { [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/code_parse.rs:180:21 [INFO] [stdout] | [INFO] [stdout] 180 | } = parse_attrs(&input, true)?; [INFO] [stdout] | ^^^^^^ help: change this to: `input` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] = note: `#[warn(clippy::needless_borrow)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/code_parse.rs:204:47 [INFO] [stdout] | [INFO] [stdout] 204 | let doc_comments = parse_doc_comments(&&content)?; [INFO] [stdout] | ^^^^^^^^^ help: change this to: `&content` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/java_jni/fenum.rs:182:53 [INFO] [stdout] | [INFO] [stdout] 182 | assert!((fenum.items.len() as u64) <= u64::from(i32::max_value() as u32)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 182 - assert!((fenum.items.len() as u64) <= u64::from(i32::max_value() as u32)); [INFO] [stdout] 182 + assert!((fenum.items.len() as u64) <= u64::from(i32::MAX as u32)); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent [INFO] [stdout] --> src/code_parse.rs:353:63 [INFO] [stdout] | [INFO] [stdout] 353 | MethodVariant::Method(ref mut self_type) => match args_in.iter().nth(0) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ help: try calling `.next()` instead of `.nth(0)`: `args_in.iter().next()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero [INFO] [stdout] = note: `#[warn(clippy::iter_nth_zero)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/code_parse.rs:437:75 [INFO] [stdout] | [INFO] [stdout] 437 | if normalize_type(constructor_ret_type) != normalize_type(&*ret_type) { [INFO] [stdout] | ^^^^^^^^^^ help: try: `&ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] = note: `#[warn(clippy::explicit_auto_deref)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: match expression looks like `matches!` macro [INFO] [stdout] --> src/code_parse.rs:713:34 [INFO] [stdout] | [INFO] [stdout] 713 | let have_self_args = match args_in.iter().nth(0) { [INFO] [stdout] | __________________________________^ [INFO] [stdout] 714 | | Some(syn::FnArg::Receiver(_)) => true, [INFO] [stdout] 715 | | _ => false, [INFO] [stdout] 716 | | }; [INFO] [stdout] | |_____________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] = note: `#[warn(clippy::match_like_matches_macro)]` on by default [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 713 - let have_self_args = match args_in.iter().nth(0) { [INFO] [stdout] 714 - Some(syn::FnArg::Receiver(_)) => true, [INFO] [stdout] 715 - _ => false, [INFO] [stdout] 716 - }; [INFO] [stdout] 713 + let have_self_args = matches!(args_in.iter().nth(0), Some(syn::FnArg::Receiver(_))); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.as_ref().map(String::as_str)` on an `Option` value [INFO] [stdout] --> src/java_jni/finterface.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | ctx.cfg.null_annotation_package.as_ref().map(String::as_str), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `ctx.cfg.null_annotation_package.as_deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/java_jni/finterface.rs:309:18 [INFO] [stdout] | [INFO] [stdout] 309 | .get(&*arg.as_ref().correspoding_rust_type.normalized_name.as_str()) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `arg.as_ref().correspoding_rust_type.normalized_name.as_str()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/java_jni/finterface.rs:311:57 [INFO] [stdout] | [INFO] [stdout] 311 | let conv_type: TokenStream = syn::parse_str(*conv_type_str).unwrap_or_else(|err| { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `conv_type_str` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:111:48 [INFO] [stdout] | [INFO] [stdout] 111 | let var_name = new_unique_name(&known_names, &templ); [INFO] [stdout] | ^^^^^^^^^^^^ help: change this to: `known_names` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:122:52 [INFO] [stdout] | [INFO] [stdout] 122 | ... Some(Cow::Borrowed(&arg_name)) [INFO] [stdout] | ^^^^^^^^^ help: change this to: `arg_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:139:60 [INFO] [stdout] | [INFO] [stdout] 139 | ... let tmp_name = new_unique_name(&known_names, name_template); [INFO] [stdout] | ^^^^^^^^^^^^ help: change this to: `known_names` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: explicit call to `.into_iter()` in function argument accepting `IntoIterator` [INFO] [stdout] --> src/cpp/cpp_code.rs:176:29 [INFO] [stdout] | [INFO] [stdout] 176 | includes.extend(mem::replace(&mut p.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()` [INFO] [stdout] --> /rustc/3645249d79dfb136b5d8de3ce153d19d6698d92d/library/core/src/iter/traits/collect.rs:416:17 [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion [INFO] [stdout] = note: `#[warn(clippy::useless_conversion)]` on by default [INFO] [stdout] help: consider removing the `.into_iter()` [INFO] [stdout] | [INFO] [stdout] 176 - includes.extend(mem::replace(&mut p.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] 176 + includes.extend(mem::replace(&mut p.provides_by_module, Vec::new())); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/cpp/cpp_code.rs:176:29 [INFO] [stdout] | [INFO] [stdout] 176 | includes.extend(mem::replace(&mut p.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut p.provides_by_module)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] = note: `#[warn(clippy::mem_replace_with_default)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: explicit call to `.into_iter()` in function argument accepting `IntoIterator` [INFO] [stdout] --> src/cpp/cpp_code.rs:178:25 [INFO] [stdout] | [INFO] [stdout] 178 | includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()` [INFO] [stdout] --> /rustc/3645249d79dfb136b5d8de3ce153d19d6698d92d/library/core/src/iter/traits/collect.rs:416:17 [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion [INFO] [stdout] help: consider removing the `.into_iter()` [INFO] [stdout] | [INFO] [stdout] 178 - includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] 178 + includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new())); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/cpp/cpp_code.rs:178:25 [INFO] [stdout] | [INFO] [stdout] 178 | includes.extend(mem::replace(&mut m.output.provides_by_module, Vec::new()).into_iter()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut m.output.provides_by_module)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/cpp_code.rs:241:45 [INFO] [stdout] | [INFO] [stdout] 241 | syn::Fields::Named(ref x) => Ok(&x), [INFO] [stdout] | ^^ help: change this to: `x` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: match expression looks like `matches!` macro [INFO] [stdout] --> src/java_jni/java_code.rs:147:5 [INFO] [stdout] | [INFO] [stdout] 147 | / match type_name { [INFO] [stdout] 148 | | "void" | "boolean" | "byte" | "short" | "int" | "long" | "float" | "double" => true, [INFO] [stdout] 149 | | _ => false, [INFO] [stdout] 150 | | } [INFO] [stdout] | |_____^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 147 - match type_name { [INFO] [stdout] 148 - "void" | "boolean" | "byte" | "short" | "int" | "long" | "float" | "double" => true, [INFO] [stdout] 149 - _ => false, [INFO] [stdout] 150 - } [INFO] [stdout] 147 + matches!(type_name, "void" | "boolean" | "byte" | "short" | "int" | "long" | "float" | "double") [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: match expression looks like `matches!` macro [INFO] [stdout] --> src/cpp/fclass.rs:39:52 [INFO] [stdout] | [INFO] [stdout] 39 | let has_methods = class.methods.iter().any(|m| match m.variant { [INFO] [stdout] | ____________________________________________________^ [INFO] [stdout] 40 | | MethodVariant::Method(_) => true, [INFO] [stdout] 41 | | _ => false, [INFO] [stdout] 42 | | }); [INFO] [stdout] | |_____^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 39 - let has_methods = class.methods.iter().any(|m| match m.variant { [INFO] [stdout] 40 - MethodVariant::Method(_) => true, [INFO] [stdout] 41 - _ => false, [INFO] [stdout] 42 - }); [INFO] [stdout] 39 + let has_methods = class.methods.iter().any(|m| matches!(m.variant, MethodVariant::Method(_))); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calling `push_str()` using a single-character string literal [INFO] [stdout] --> src/java_jni/rust_code.rs:77:5 [INFO] [stdout] | [INFO] [stdout] 77 | output.push_str("_"); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `output.push('_')` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str [INFO] [stdout] = note: `#[warn(clippy::single_char_add_str)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calling `push_str()` using a single-character string literal [INFO] [stdout] --> src/java_jni/rust_code.rs:79:5 [INFO] [stdout] | [INFO] [stdout] 79 | output.push_str("_"); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `output.push('_')` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/rust_code.rs:146:31 [INFO] [stdout] | [INFO] [stdout] 146 | let code = str::from_utf8(&generated_code).map_err(|err| { [INFO] [stdout] | ^^^^^^^^^^^^^^^ help: change this to: `generated_code` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:738:9 [INFO] [stdout] | [INFO] [stdout] 738 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:746:9 [INFO] [stdout] | [INFO] [stdout] 746 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:796:9 [INFO] [stdout] | [INFO] [stdout] 796 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:804:9 [INFO] [stdout] | [INFO] [stdout] 804 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:821:9 [INFO] [stdout] | [INFO] [stdout] 821 | &c_ret_type, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `c_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:877:9 [INFO] [stdout] | [INFO] [stdout] 877 | &ret_type_name, [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `ret_type_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/cpp/fclass.rs:885:9 [INFO] [stdout] | [INFO] [stdout] 885 | &ret_type_name, [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `ret_type_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this function has too many arguments (9/7) [INFO] [stdout] --> src/cpp/fclass.rs:1022:1 [INFO] [stdout] | [INFO] [stdout] 1022 | / fn generate_cpp_header_preamble( [INFO] [stdout] 1023 | | ctx: &mut CppContext, [INFO] [stdout] 1024 | | class: &ForeignerClassInfo, [INFO] [stdout] 1025 | | tmp_class_name: &str, [INFO] [stdout] ... | [INFO] [stdout] 1031 | | cpp_include_f: &mut FileWriteCache, [INFO] [stdout] 1032 | | ) -> Result<()> { [INFO] [stdout] | |_______________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stdout] = note: `#[warn(clippy::too_many_arguments)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/cpp/fenum.rs:20:48 [INFO] [stdout] | [INFO] [stdout] 20 | if (fenum.items.len() as u64) >= u64::from(u32::max_value()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] = note: `#[warn(clippy::legacy_numeric_constants)]` on by default [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 20 - if (fenum.items.len() as u64) >= u64::from(u32::max_value()) { [INFO] [stdout] 20 + if (fenum.items.len() as u64) >= u64::from(u32::MAX) { [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/cpp/fenum.rs:136:57 [INFO] [stdout] | [INFO] [stdout] 136 | assert!((enum_info.items.len() as u64) <= u64::from(u32::max_value())); [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 136 - assert!((enum_info.items.len() as u64) <= u64::from(u32::max_value())); [INFO] [stdout] 136 + assert!((enum_info.items.len() as u64) <= u64::from(u32::MAX)); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: manual implementation of `Option::map` [INFO] [stdout] --> src/java_jni/mod.rs:272:5 [INFO] [stdout] | [INFO] [stdout] 272 | / if let Some(constructor_ret_type) = class.self_desc.as_ref().map(|x| &x.constructor_ret_type) { [INFO] [stdout] 273 | | Some( [INFO] [stdout] 274 | | if_result_return_ok_err_types( [INFO] [stdout] 275 | | &tm.ty_to_rust_type_checked(constructor_ret_type) [INFO] [stdout] ... | [INFO] [stdout] 288 | | None [INFO] [stdout] 289 | | } [INFO] [stdout] | |_____^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_map [INFO] [stdout] = note: `#[warn(clippy::manual_map)]` on by default [INFO] [stdout] help: try [INFO] [stdout] | [INFO] [stdout] 272 ~ class.self_desc.as_ref().map(|x| &x.constructor_ret_type).map(|constructor_ret_type| if_result_return_ok_err_types( [INFO] [stdout] 273 + &tm.ty_to_rust_type_checked(constructor_ret_type) [INFO] [stdout] 274 + .unwrap_or_else(|| { [INFO] [stdout] 275 + panic!( [INFO] [stdout] 276 + "Internal error: constructor type {} for class {} unknown", [INFO] [stdout] 277 + DisplayToTokens(constructor_ret_type), [INFO] [stdout] 278 + class.name [INFO] [stdout] 279 + ); [INFO] [stdout] 280 + }), [INFO] [stdout] 281 + ) [INFO] [stdout] 282 + .map(|(ok_ty, _err_ty)| ok_ty) [INFO] [stdout] 283 + .unwrap_or_else(|| constructor_ret_type.clone())) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/java_jni/mod.rs:355:15 [INFO] [stdout] | [INFO] [stdout] 355 | .join(&format!("{}.java", INTERNAL_PTR_MARKER)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `format!("{}.java", INTERNAL_PTR_MARKER)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] = note: `#[warn(clippy::needless_borrows_for_generic_args)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/java_jni/mod.rs:382:23 [INFO] [stdout] | [INFO] [stdout] 382 | .join(&format!("{}.java", REACHABILITY_FENCE_CLASS)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `format!("{}.java", REACHABILITY_FENCE_CLASS)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/namegen.rs:18:19 [INFO] [stdout] | [INFO] [stdout] 18 | if idx == u64::max_value() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 18 - if idx == u64::max_value() { [INFO] [stdout] 18 + if idx == u64::MAX { [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this function has too many arguments (8/7) [INFO] [stdout] --> src/cpp/map_class_self_type.rs:126:1 [INFO] [stdout] | [INFO] [stdout] 126 | / fn register_rust_ty_conversation_rules( [INFO] [stdout] 127 | | conv_map: &mut TypeMap, [INFO] [stdout] 128 | | class: &ForeignerClassInfo, [INFO] [stdout] 129 | | this_type: RustType, [INFO] [stdout] ... | [INFO] [stdout] 134 | | this_type_mut_ref: RustTypeIdx, [INFO] [stdout] 135 | | ) -> Result<()> { [INFO] [stdout] | |_______________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this function has too many arguments (8/7) [INFO] [stdout] --> src/cpp/map_class_self_type.rs:245:1 [INFO] [stdout] | [INFO] [stdout] 245 | / fn register_main_foreign_types( [INFO] [stdout] 246 | | conv_map: &mut TypeMap, [INFO] [stdout] 247 | | class: &ForeignerClassInfo, [INFO] [stdout] 248 | | this_type: RustTypeIdx, [INFO] [stdout] ... | [INFO] [stdout] 253 | | this_type_mut_ref: RustTypeIdx, [INFO] [stdout] 254 | | ) -> Result<()> { [INFO] [stdout] | |_______________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:233:48 [INFO] [stdout] | [INFO] [stdout] 233 | let storage_type = wrap_type_for_class(&rust_self_type, storage_smart_pointer.pointer_type); [INFO] [stdout] | ^^^^^^^^^^^^^^^ help: change this to: `rust_self_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `to_string` applied to a type that implements `Display` in `format!` args [INFO] [stdout] --> src/python/mod.rs:311:63 [INFO] [stdout] | [INFO] [stdout] 311 | &format!("{}: {}", name, t.into_token_stream().to_string()), [INFO] [stdout] | ^^^^^^^^^^^^ help: remove this [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args [INFO] [stdout] = note: `#[warn(clippy::to_string_in_format_args)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let .. else` expression looks like `matches!` macro [INFO] [stdout] --> src/python/mod.rs:418:9 [INFO] [stdout] | [INFO] [stdout] 418 | / if let MethodVariant::Method(_) = m.variant { [INFO] [stdout] 419 | | true [INFO] [stdout] 420 | | } else { [INFO] [stdout] 421 | | false [INFO] [stdout] 422 | | } [INFO] [stdout] | |_________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 418 - if let MethodVariant::Method(_) = m.variant { [INFO] [stdout] 419 - true [INFO] [stdout] 420 - } else { [INFO] [stdout] 421 - false [INFO] [stdout] 422 - } [INFO] [stdout] 418 + matches!(m.variant, MethodVariant::Method(_)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:460:65 [INFO] [stdout] | [INFO] [stdout] 460 | } else if let Some(inner) = ast::if_option_return_some_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:480:47 [INFO] [stdout] | [INFO] [stdout] 480 | &conv_map.find_or_alloc_rust_type(&inner, src_id), [INFO] [stdout] | ^^^^^^ help: change this to: `inner` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:493:57 [INFO] [stdout] | [INFO] [stdout] 493 | } else if let Some(inner) = if_vec_return_elem_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:517:47 [INFO] [stdout] | [INFO] [stdout] 517 | &conv_map.find_or_alloc_rust_type(&inner.elem.deref(), src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `inner.elem.deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:556:9 [INFO] [stdout] | [INFO] [stdout] 556 | &rust_type, [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:573:65 [INFO] [stdout] | [INFO] [stdout] 573 | } else if let Some(inner) = ast::if_option_return_some_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:592:47 [INFO] [stdout] | [INFO] [stdout] 592 | &conv_map.find_or_alloc_rust_type(&inner, src_id), [INFO] [stdout] | ^^^^^^ help: change this to: `inner` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/cpp/mod.rs:498:19 [INFO] [stdout] | [INFO] [stdout] 498 | let f_codes = mem::replace(&mut rule.f_code, vec![]); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut rule.f_code)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:604:57 [INFO] [stdout] | [INFO] [stdout] 604 | } else if let Some(inner) = if_vec_return_elem_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:618:85 [INFO] [stdout] | [INFO] [stdout] 618 | } else if let Some((inner_ok, _inner_err)) = ast::if_result_return_ok_err_types(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:640:47 [INFO] [stdout] | [INFO] [stdout] 640 | &conv_map.find_or_alloc_rust_type(&inner.elem.deref(), src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `inner.elem.deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:769:55 [INFO] [stdout] | [INFO] [stdout] 769 | ast::check_if_smart_pointer_return_inner_type(&rust_type, "Mutex") [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:775:82 [INFO] [stdout] | [INFO] [stdout] 775 | } else if let Some(inner_ty) = ast::check_if_smart_pointer_return_inner_type(&rust_type, "Box") [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/python/mod.rs:802:50 [INFO] [stdout] | [INFO] [stdout] 802 | conv_map.find_or_alloc_rust_type(&*reference.elem, src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^ help: try: `&reference.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/python/mod.rs:807:50 [INFO] [stdout] | [INFO] [stdout] 807 | conv_map.find_or_alloc_rust_type(&*reference.elem, src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^ help: try: `&reference.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/error.rs:105:31 [INFO] [stdout] | [INFO] [stdout] 105 | code_problem.push_str(&line); [INFO] [stdout] | ^^^^^ help: change this to: `line` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/file_cache.rs:59:9 [INFO] [stdout] | [INFO] [stdout] 59 | ::std::mem::replace(&mut self.cnt, vec![]) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut self.cnt)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.as_ref().map(String::as_str)` on an `Option` value [INFO] [stdout] --> src/java_jni/fclass.rs:47:9 [INFO] [stdout] | [INFO] [stdout] 47 | ctx.cfg.null_annotation_package.as_ref().map(String::as_str), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `ctx.cfg.null_annotation_package.as_deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref [INFO] [stdout] = note: `#[warn(clippy::option_as_ref_deref)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:192:43 [INFO] [stdout] | [INFO] [stdout] 192 | .replace(TO_VAR_TEMPLATE, &conv_ret); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `conv_ret` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/python/mod.rs:1266:18 [INFO] [stdout] | [INFO] [stdout] 1266 | Some(&*elem) [INFO] [stdout] | ^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] help: if you would like to reborrow, try removing `&*` [INFO] [stdout] | [INFO] [stdout] 1266 - Some(&*elem) [INFO] [stdout] 1266 + Some(elem) [INFO] [stdout] | [INFO] [stdout] help: if you would like to deref, try using `&**` [INFO] [stdout] | [INFO] [stdout] 1266 | Some(&**elem) [INFO] [stdout] | + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/ast/subst_map.rs:6:6 [INFO] [stdout] | [INFO] [stdout] 6 | impl<'a> PartialEq> for Ident { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] = note: `#[warn(clippy::extra_unused_lifetimes)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: manual implementation of `Option::map` [INFO] [stdout] --> src/typemap/ast/subst_map.rs:45:9 [INFO] [stdout] | [INFO] [stdout] 45 | / match self.inner.iter().position(|it| it.ident == k) { [INFO] [stdout] 46 | | Some(idx) => Some(self.inner[idx].ty.as_ref()), [INFO] [stdout] 47 | | None => None, [INFO] [stdout] 48 | | } [INFO] [stdout] | |_________^ help: try: `self.inner.iter().position(|it| it.ident == k).map(|idx| self.inner[idx].ty.as_ref())` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_map [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:128:32 [INFO] [stdout] | [INFO] [stdout] 128 | INTERNER.with(|interner| f(&mut *interner.borrow_mut())) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut interner.borrow_mut()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let .. else` expression looks like `matches!` macro [INFO] [stdout] --> src/typemap/ast.rs:147:17 [INFO] [stdout] | [INFO] [stdout] 147 | / if let syn::GenericArgument::Lifetime(_) = x { [INFO] [stdout] 148 | | false [INFO] [stdout] 149 | | } else { [INFO] [stdout] 150 | | true [INFO] [stdout] 151 | | } [INFO] [stdout] | |_________________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 147 - if let syn::GenericArgument::Lifetime(_) = x { [INFO] [stdout] 148 - false [INFO] [stdout] 149 - } else { [INFO] [stdout] 150 - true [INFO] [stdout] 151 - } [INFO] [stdout] 147 + !matches!(x, syn::GenericArgument::Lifetime(_)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.iter().nth()` on a slice [INFO] [stdout] --> src/typemap/ast.rs:318:18 [INFO] [stdout] | [INFO] [stdout] 318 | }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth [INFO] [stdout] = note: `#[warn(clippy::iter_nth)]` on by default [INFO] [stdout] help: `get` is equivalent but more concise [INFO] [stdout] | [INFO] [stdout] 318 - }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] 318 + }) = subst_map.as_slice().get(0).as_ref() [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:322:79 [INFO] [stdout] | [INFO] [stdout] 322 | (*from_foreigner_hint.as_str()).replace(&key.to_string(), &val_name); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `val_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:325:56 [INFO] [stdout] | [INFO] [stdout] 325 | != RustTypeS::make_unique_typename(&clean_from_ty, &foreign_name) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `clean_from_ty` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.iter().nth()` on a slice [INFO] [stdout] --> src/typemap/ast.rs:339:18 [INFO] [stdout] | [INFO] [stdout] 339 | }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth [INFO] [stdout] help: `get` is equivalent but more concise [INFO] [stdout] | [INFO] [stdout] 339 - }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] 339 + }) = subst_map.as_slice().get(0).as_ref() [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/java_jni/fclass.rs:668:64 [INFO] [stdout] | [INFO] [stdout] 668 | syn::ReturnType::Type(_, ref ty) => normalize_type(&*ty), [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] = note: `#[warn(clippy::borrow_deref_ref)]` on by default [INFO] [stdout] help: if you would like to reborrow, try removing `&*` [INFO] [stdout] | [INFO] [stdout] 668 - syn::ReturnType::Type(_, ref ty) => normalize_type(&*ty), [INFO] [stdout] 668 + syn::ReturnType::Type(_, ref ty) => normalize_type(ty), [INFO] [stdout] | [INFO] [stdout] help: if you would like to deref, try using `&**` [INFO] [stdout] | [INFO] [stdout] 668 | syn::ReturnType::Type(_, ref ty) => normalize_type(&**ty), [INFO] [stdout] | + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:343:77 [INFO] [stdout] | [INFO] [stdout] 343 | (*to_foreigner_hint.as_str()).replace(&key.to_string(), &val_name); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `val_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this `map_or` can be simplified [INFO] [stdout] --> src/typemap/ast.rs:371:9 [INFO] [stdout] | [INFO] [stdout] 371 | others(val_name).map_or(true, |rt| !rt.implements.contains_subset(requires)) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or [INFO] [stdout] = note: `#[warn(clippy::unnecessary_map_or)]` on by default [INFO] [stdout] help: use `is_none_or` instead [INFO] [stdout] | [INFO] [stdout] 371 - others(val_name).map_or(true, |rt| !rt.implements.contains_subset(requires)) [INFO] [stdout] 371 + others(val_name).is_none_or(|rt| !rt.implements.contains_subset(requires)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this `map_or` can be simplified [INFO] [stdout] --> src/typemap/ast.rs:373:6 [INFO] [stdout] | [INFO] [stdout] 373 | !trait_bounds [INFO] [stdout] | ______^ [INFO] [stdout] 374 | | .iter() [INFO] [stdout] 375 | | .position(|it| it.ty_param.as_ref() == subst_ident) [INFO] [stdout] 376 | | .map_or(false, traits_bound_not_match) [INFO] [stdout] | |______________________________________________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or [INFO] [stdout] help: use `is_some_and` instead [INFO] [stdout] | [INFO] [stdout] 376 - .map_or(false, traits_bound_not_match) [INFO] [stdout] 376 + .is_some_and(traits_bound_not_match) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:677:35 [INFO] [stdout] | [INFO] [stdout] 677 | real_output_typename: &real_output_typename, [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `real_output_typename` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:400:42 [INFO] [stdout] | [INFO] [stdout] 400 | is_second_subst_of_first(&*mut_ty1.elem, &*mut_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&mut_ty1.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:400:58 [INFO] [stdout] | [INFO] [stdout] 400 | is_second_subst_of_first(&*mut_ty1.elem, &*mut_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&mut_ty2.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:408:42 [INFO] [stdout] | [INFO] [stdout] 408 | is_second_subst_of_first(&*ptr_ty1.elem, &*ptr_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&ptr_ty1.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:408:58 [INFO] [stdout] | [INFO] [stdout] 408 | is_second_subst_of_first(&*ptr_ty1.elem, &*ptr_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&ptr_ty2.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:412:38 [INFO] [stdout] | [INFO] [stdout] 412 | is_second_subst_of_first(&*ty1.elem, &*ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^ help: try: `&ty1.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:412:50 [INFO] [stdout] | [INFO] [stdout] 412 | is_second_subst_of_first(&*ty1.elem, &*ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^ help: try: `&ty2.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:857:9 [INFO] [stdout] | [INFO] [stdout] 857 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:866:9 [INFO] [stdout] | [INFO] [stdout] 866 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:981:9 [INFO] [stdout] | [INFO] [stdout] 981 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/fclass.rs:990:9 [INFO] [stdout] | [INFO] [stdout] 990 | &jni_ret_type, [INFO] [stdout] | ^^^^^^^^^^^^^ help: change this to: `jni_ret_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/ast.rs:698:6 [INFO] [stdout] | [INFO] [stdout] 698 | impl<'a> PartialEq for TyParamRef<'_> { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/ast.rs:704:6 [INFO] [stdout] | [INFO] [stdout] 704 | impl<'a> AsRef for TyParamRef<'_> { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:708:35 [INFO] [stdout] | [INFO] [stdout] 708 | TyParamRef::Own(x) => &x, [INFO] [stdout] | ^^ help: change this to: `x` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:739:45 [INFO] [stdout] | [INFO] [stdout] 739 | ret_elem.trait_names.insert(&trait_path); [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `trait_path` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/java_jni/fenum.rs:31:39 [INFO] [stdout] | [INFO] [stdout] 31 | if (fenum.items.len() as u64) >= (i32::max_value() as u64) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 31 - if (fenum.items.len() as u64) >= (i32::max_value() as u64) { [INFO] [stdout] 31 + if (fenum.items.len() as u64) >= (i32::MAX as u64) { [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:756:25 [INFO] [stdout] | [INFO] [stdout] 756 | &normalize_type(bounded_ty), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `normalize_type(bounded_ty)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:768:53 [INFO] [stdout] | [INFO] [stdout] 768 | ret_elem.trait_names.insert(&trait_path); [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `trait_path` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:853:25 [INFO] [stdout] | [INFO] [stdout] 853 | self.0.push(&lifetime); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `lifetime` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/java_jni/fenum.rs:182:53 [INFO] [stdout] | [INFO] [stdout] 182 | assert!((fenum.items.len() as u64) <= u64::from(i32::max_value() as u32)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 182 - assert!((fenum.items.len() as u64) <= u64::from(i32::max_value() as u32)); [INFO] [stdout] 182 + assert!((fenum.items.len() as u64) <= u64::from(i32::MAX as u32)); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: stripping a prefix manually [INFO] [stdout] --> src/typemap/parse.rs:334:33 [INFO] [stdout] | [INFO] [stdout] 334 | ... &val[1..] [INFO] [stdout] | ^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: the prefix was tested here [INFO] [stdout] --> src/typemap/parse.rs:333:39 [INFO] [stdout] | [INFO] [stdout] 333 | ... let val = if val.starts_with('"') { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip [INFO] [stdout] = note: `#[warn(clippy::manual_strip)]` on by default [INFO] [stdout] help: try using the `strip_prefix` method [INFO] [stdout] | [INFO] [stdout] 333 ~ let val = if let Some() = val.strip_prefix('"') { [INFO] [stdout] 334 ~ [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: stripping a suffix manually [INFO] [stdout] --> src/typemap/parse.rs:339:33 [INFO] [stdout] | [INFO] [stdout] 339 | ... &val[..val.len() - 1] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: the suffix was tested here [INFO] [stdout] --> src/typemap/parse.rs:338:39 [INFO] [stdout] | [INFO] [stdout] 338 | ... let val = if val.ends_with('"') { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip [INFO] [stdout] help: try using the `strip_suffix` method [INFO] [stdout] | [INFO] [stdout] 338 ~ let val = if let Some() = val.strip_suffix('"') { [INFO] [stdout] 339 ~ [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:341:33 [INFO] [stdout] | [INFO] [stdout] 341 | ... &val [INFO] [stdout] | ^^^^ help: change this to: `val` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.as_ref().map(String::as_str)` on an `Option` value [INFO] [stdout] --> src/java_jni/finterface.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | ctx.cfg.null_annotation_package.as_ref().map(String::as_str), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `ctx.cfg.null_annotation_package.as_deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> src/typemap/parse.rs:388:29 [INFO] [stdout] | [INFO] [stdout] 388 | fn get_swig_code_from_attrs<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] 389 | item_span: SourceIdSpan, [INFO] [stdout] 390 | swig_code_attr_name: &'a str, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] = note: `#[warn(clippy::needless_lifetimes)]` on by default [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 388 ~ fn get_swig_code_from_attrs<'b>( [INFO] [stdout] 389 | item_span: SourceIdSpan, [INFO] [stdout] 390 ~ swig_code_attr_name: &str, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:404:55 [INFO] [stdout] | [INFO] [stdout] 404 | validate_code_template((item_span.0, sp), &conv_code_template.as_str())?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `conv_code_template.as_str()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:492:17 [INFO] [stdout] | [INFO] [stdout] 492 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:498:17 [INFO] [stdout] | [INFO] [stdout] 498 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:576:17 [INFO] [stdout] | [INFO] [stdout] 576 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:582:17 [INFO] [stdout] | [INFO] [stdout] 582 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:641:74 [INFO] [stdout] | [INFO] [stdout] 641 | get_swig_code_from_attrs((src_id, item_macro.span()), SWIG_CODE, &swig_attrs)?; [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:664:13 [INFO] [stdout] | [INFO] [stdout] 664 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:670:13 [INFO] [stdout] | [INFO] [stdout] 670 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/typemap/parse.rs:758:49 [INFO] [stdout] | [INFO] [stdout] 758 | err.span_note((src_id, attrs[0].1), &format!("First {}", attr_name)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `format!("First {}", attr_name)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/java_jni/finterface.rs:309:18 [INFO] [stdout] | [INFO] [stdout] 309 | .get(&*arg.as_ref().correspoding_rust_type.normalized_name.as_str()) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `arg.as_ref().correspoding_rust_type.normalized_name.as_str()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/java_jni/finterface.rs:311:57 [INFO] [stdout] | [INFO] [stdout] 311 | let conv_type: TokenStream = syn::parse_str(*conv_type_str).unwrap_or_else(|err| { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `conv_type_str` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'b [INFO] [stdout] --> src/typemap/parse.rs:812:37 [INFO] [stdout] | [INFO] [stdout] 812 | fn unpack_first_associated_type<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] 813 | items: &'a [syn::ImplItem], [INFO] [stdout] 814 | assoc_type_name: &'b str, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 812 ~ fn unpack_first_associated_type<'a>( [INFO] [stdout] 813 | items: &'a [syn::ImplItem], [INFO] [stdout] 814 ~ assoc_type_name: &str, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/ty.rs:109:13 [INFO] [stdout] | [INFO] [stdout] 109 | if !self.inner.iter().any(|it| x == *it) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `self.inner.contains(&x)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] = note: `#[warn(clippy::manual_contains)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: match expression looks like `matches!` macro [INFO] [stdout] --> src/java_jni/java_code.rs:147:5 [INFO] [stdout] | [INFO] [stdout] 147 | / match type_name { [INFO] [stdout] 148 | | "void" | "boolean" | "byte" | "short" | "int" | "long" | "float" | "double" => true, [INFO] [stdout] 149 | | _ => false, [INFO] [stdout] 150 | | } [INFO] [stdout] | |_____^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 147 - match type_name { [INFO] [stdout] 148 - "void" | "boolean" | "byte" | "short" | "int" | "long" | "float" | "double" => true, [INFO] [stdout] 149 - _ => false, [INFO] [stdout] 150 - } [INFO] [stdout] 147 + matches!(type_name, "void" | "boolean" | "byte" | "short" | "int" | "long" | "float" | "double") [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/typemap_macro/parse.rs:347:25 [INFO] [stdout] | [INFO] [stdout] 347 | if !f.attrs.iter().any(|a| *a == mangle_attr) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `f.attrs.contains(&mangle_attr)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/typemap_macro/parse.rs:380:5 [INFO] [stdout] | [INFO] [stdout] 380 | attrs.iter().any(|a| *a == repr_c_attr) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `attrs.contains(&repr_c_attr)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/typemap_macro/parse.rs:564:16 [INFO] [stdout] | [INFO] [stdout] 564 | if temporary_ids.iter().any(|x| *x == var_name) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `temporary_ids.contains(&var_name)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calling `push_str()` using a single-character string literal [INFO] [stdout] --> src/java_jni/rust_code.rs:77:5 [INFO] [stdout] | [INFO] [stdout] 77 | output.push_str("_"); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `output.push('_')` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str [INFO] [stdout] = note: `#[warn(clippy::single_char_add_str)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calling `push_str()` using a single-character string literal [INFO] [stdout] --> src/java_jni/rust_code.rs:79:5 [INFO] [stdout] | [INFO] [stdout] 79 | output.push_str("_"); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `output.push('_')` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: non-canonical implementation of `partial_cmp` on an `Ord` type [INFO] [stdout] --> src/typemap/typemap_macro.rs:106:1 [INFO] [stdout] | [INFO] [stdout] 106 | / impl PartialOrd for ModuleName { [INFO] [stdout] 107 | | fn partial_cmp(&self, other: &Self) -> Option { [INFO] [stdout] 108 | | Some(self.name.cmp(&other.name)) [INFO] [stdout] 109 | | } [INFO] [stdout] 110 | | } [INFO] [stdout] | |_^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#non_canonical_partial_ord_impl [INFO] [stdout] = note: `#[warn(clippy::non_canonical_partial_ord_impl)]` on by default [INFO] [stdout] help: change this to [INFO] [stdout] | [INFO] [stdout] 107 - fn partial_cmp(&self, other: &Self) -> Option { [INFO] [stdout] 108 - Some(self.name.cmp(&other.name)) [INFO] [stdout] 109 - } [INFO] [stdout] 107 + fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/java_jni/rust_code.rs:146:31 [INFO] [stdout] | [INFO] [stdout] 146 | let code = str::from_utf8(&generated_code).map_err(|err| { [INFO] [stdout] | ^^^^^^^^^^^^^^^ help: change this to: `generated_code` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: accessing first element with `self.ftype_left_to_right.get(0)` [INFO] [stdout] --> src/typemap/typemap_macro.rs:141:13 [INFO] [stdout] | [INFO] [stdout] 141 | self.ftype_left_to_right.get(0), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `self.ftype_left_to_right.first()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_first [INFO] [stdout] = note: `#[warn(clippy::get_first)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/typemap_macro.rs:251:71 [INFO] [stdout] | [INFO] [stdout] 251 | build_generic_aliases(self.src_id, &self.generic_aliases, ¶m_map, expander)?; [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `param_map` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'b [INFO] [stdout] --> src/typemap/typemap_macro.rs:479:30 [INFO] [stdout] | [INFO] [stdout] 479 | fn build_generic_aliases<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] ... [INFO] [stdout] 482 | param_map: &'b TyParamsSubstMap, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 479 ~ fn build_generic_aliases<'a>( [INFO] [stdout] 480 | src_id: SourceId, [INFO] [stdout] 481 | generic_aliases: &'a [GenericAlias], [INFO] [stdout] 482 ~ param_map: &TyParamsSubstMap, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.as_ref().map(String::as_str)` on an `Option` value [INFO] [stdout] --> src/typemap/typemap_macro.rs:557:17 [INFO] [stdout] | [INFO] [stdout] 557 | / opt_arg [INFO] [stdout] 558 | | .as_ref() [INFO] [stdout] 559 | | .map(syn::Ident::to_string) [INFO] [stdout] 560 | | .as_ref() [INFO] [stdout] 561 | | .map(String::as_str), [INFO] [stdout] | |________________________________________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref [INFO] [stdout] help: consider using as_deref [INFO] [stdout] | [INFO] [stdout] 557 ~ opt_arg [INFO] [stdout] 558 + .as_ref() [INFO] [stdout] 559 ~ .map(syn::Ident::to_string).as_deref(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:583:15 [INFO] [stdout] | [INFO] [stdout] 583 | match (&code[prev_pos..]).find(char::is_alphabetic) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[prev_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:592:27 [INFO] [stdout] | [INFO] [stdout] 592 | match (&code[prev_pos..]).find(|ch: char| !ch.is_alphabetic()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[prev_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:617:33 [INFO] [stdout] | [INFO] [stdout] 617 | let mut next_pos = id_end + (&code[id_end..]).find(|ch: char| !ch.is_whitespace())?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ help: change this to: `code[id_end..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:622:27 [INFO] [stdout] | [INFO] [stdout] 622 | next_pos = next_pos + (&code[next_pos..]).find(|ch: char| !ch.is_whitespace())?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[next_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:630:22 [INFO] [stdout] | [INFO] [stdout] 630 | for (idx, ch) in (&code[next_pos..]).chars().enumerate() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[next_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:644:29 [INFO] [stdout] | [INFO] [stdout] 644 | let params: Vec<&str> = (&code[cnt_start..cnt_end]) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `code[cnt_start..cnt_end]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: manual implementation of `Option::map` [INFO] [stdout] --> src/java_jni/mod.rs:272:5 [INFO] [stdout] | [INFO] [stdout] 272 | / if let Some(constructor_ret_type) = class.self_desc.as_ref().map(|x| &x.constructor_ret_type) { [INFO] [stdout] 273 | | Some( [INFO] [stdout] 274 | | if_result_return_ok_err_types( [INFO] [stdout] 275 | | &tm.ty_to_rust_type_checked(constructor_ret_type) [INFO] [stdout] ... | [INFO] [stdout] 288 | | None [INFO] [stdout] 289 | | } [INFO] [stdout] | |_____^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_map [INFO] [stdout] = note: `#[warn(clippy::manual_map)]` on by default [INFO] [stdout] help: try [INFO] [stdout] | [INFO] [stdout] 272 ~ class.self_desc.as_ref().map(|x| &x.constructor_ret_type).map(|constructor_ret_type| if_result_return_ok_err_types( [INFO] [stdout] 273 + &tm.ty_to_rust_type_checked(constructor_ret_type) [INFO] [stdout] 274 + .unwrap_or_else(|| { [INFO] [stdout] 275 + panic!( [INFO] [stdout] 276 + "Internal error: constructor type {} for class {} unknown", [INFO] [stdout] 277 + DisplayToTokens(constructor_ret_type), [INFO] [stdout] 278 + class.name [INFO] [stdout] 279 + ); [INFO] [stdout] 280 + }), [INFO] [stdout] 281 + ) [INFO] [stdout] 282 + .map(|(ok_ty, _err_ty)| ok_ty) [INFO] [stdout] 283 + .unwrap_or_else(|| constructor_ret_type.clone())) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:913:26 [INFO] [stdout] | [INFO] [stdout] 913 | let alias_name = (&type_name[0..type_name.len() - 3]).trim(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `type_name[0..type_name.len() - 3]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/java_jni/mod.rs:355:15 [INFO] [stdout] | [INFO] [stdout] 355 | .join(&format!("{}.java", INTERNAL_PTR_MARKER)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `format!("{}.java", INTERNAL_PTR_MARKER)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] = note: `#[warn(clippy::needless_borrows_for_generic_args)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/java_jni/mod.rs:382:23 [INFO] [stdout] | [INFO] [stdout] 382 | .join(&format!("{}.java", REACHABILITY_FENCE_CLASS)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `format!("{}.java", REACHABILITY_FENCE_CLASS)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: large size difference between variants [INFO] [stdout] --> src/typemap/typemap_macro.rs:1003:1 [INFO] [stdout] | [INFO] [stdout] 1003 | / enum TyValueOrRef<'a> { [INFO] [stdout] 1004 | | Value(Type), [INFO] [stdout] | | ----------- the largest variant contains at least 352 bytes [INFO] [stdout] 1005 | | Ref(&'a Type), [INFO] [stdout] | | ------------- the second-largest variant contains at least 8 bytes [INFO] [stdout] 1006 | | } [INFO] [stdout] | |_^ the entire enum is at least 352 bytes [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stdout] = note: `#[warn(clippy::large_enum_variant)]` on by default [INFO] [stdout] help: consider boxing the large fields or introducing indirection in some other way to reduce the total size of the enum [INFO] [stdout] | [INFO] [stdout] 1004 - Value(Type), [INFO] [stdout] 1004 + Value(Box), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/typemap_macro.rs:1008:6 [INFO] [stdout] | [INFO] [stdout] 1008 | impl<'a> AsRef for TyValueOrRef<'_> { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> src/typemap/typemap_macro.rs:1017:20 [INFO] [stdout] | [INFO] [stdout] 1017 | fn find_type_param<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] 1018 | param_map: &'b TyParamsSubstMap, [INFO] [stdout] 1019 | param: &'a str, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1017 ~ fn find_type_param<'b>( [INFO] [stdout] 1018 | param_map: &'b TyParamsSubstMap, [INFO] [stdout] 1019 ~ param: &str, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> src/namegen.rs:18:19 [INFO] [stdout] | [INFO] [stdout] 18 | if idx == u64::max_value() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 18 - if idx == u64::max_value() { [INFO] [stdout] 18 + if idx == u64::MAX { [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calling `push_str()` using a single-character string literal [INFO] [stdout] --> src/typemap/typemap_macro.rs:1152:25 [INFO] [stdout] | [INFO] [stdout] 1152 | out.push_str(")"); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `out.push(')')` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/utils.rs:235:80 [INFO] [stdout] | [INFO] [stdout] 235 | if let Some(inner_ty) = check_if_smart_pointer_return_inner_type(from, *smart_pointer) { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/utils.rs:251:80 [INFO] [stdout] | [INFO] [stdout] 251 | if let Some(inner_ty) = check_if_smart_pointer_return_inner_type(from, *smart_pointer) { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/utils.rs:254:57 [INFO] [stdout] | [INFO] [stdout] 254 | let smart_pointer_ty: Type = syn::parse_str(&smart_pointer).unwrap_or_else(|err| { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/utils.rs:284:59 [INFO] [stdout] | [INFO] [stdout] 284 | if check_if_smart_pointer_return_inner_type(from, *smart_pointer).is_some() { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:233:48 [INFO] [stdout] | [INFO] [stdout] 233 | let storage_type = wrap_type_for_class(&rust_self_type, storage_smart_pointer.pointer_type); [INFO] [stdout] | ^^^^^^^^^^^^^^^ help: change this to: `rust_self_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/typemap/utils.rs:360:32 [INFO] [stdout] | [INFO] [stdout] 360 | let entries = fs::read_dir(&output_dir) [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `output_dir` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `to_string` applied to a type that implements `Display` in `format!` args [INFO] [stdout] --> src/python/mod.rs:311:63 [INFO] [stdout] | [INFO] [stdout] 311 | &format!("{}: {}", name, t.into_token_stream().to_string()), [INFO] [stdout] | ^^^^^^^^^^^^ help: remove this [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args [INFO] [stdout] = note: `#[warn(clippy::to_string_in_format_args)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: stripping a prefix manually [INFO] [stdout] --> src/typemap.rs:164:45 [INFO] [stdout] | [INFO] [stdout] 164 | TypeConvCodeSubstParam::Tmp(&p[1..]) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: the prefix was tested here [INFO] [stdout] --> src/typemap.rs:163:28 [INFO] [stdout] | [INFO] [stdout] 163 | let param_id = if p.starts_with('$') { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip [INFO] [stdout] help: try using the `strip_prefix` method [INFO] [stdout] | [INFO] [stdout] 163 ~ let param_id = if let Some() = p.strip_prefix('$') { [INFO] [stdout] 164 ~ TypeConvCodeSubstParam::Tmp() [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap.rs:166:46 [INFO] [stdout] | [INFO] [stdout] 166 | TypeConvCodeSubstParam::Name(&p) [INFO] [stdout] | ^^ help: change this to: `p` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: direct implementation of `ToString` [INFO] [stdout] --> src/typemap.rs:184:1 [INFO] [stdout] | [INFO] [stdout] 184 | / impl ToString for TypeConvCode { [INFO] [stdout] 185 | | fn to_string(&self) -> String { [INFO] [stdout] 186 | | self.code.clone() [INFO] [stdout] 187 | | } [INFO] [stdout] 188 | | } [INFO] [stdout] | |_^ [INFO] [stdout] | [INFO] [stdout] = help: prefer implementing `Display` instead [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#to_string_trait_impl [INFO] [stdout] = note: `#[warn(clippy::to_string_trait_impl)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let .. else` expression looks like `matches!` macro [INFO] [stdout] --> src/python/mod.rs:418:9 [INFO] [stdout] | [INFO] [stdout] 418 | / if let MethodVariant::Method(_) = m.variant { [INFO] [stdout] 419 | | true [INFO] [stdout] 420 | | } else { [INFO] [stdout] 421 | | false [INFO] [stdout] 422 | | } [INFO] [stdout] | |_________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 418 - if let MethodVariant::Method(_) = m.variant { [INFO] [stdout] 419 - true [INFO] [stdout] 420 - } else { [INFO] [stdout] 421 - false [INFO] [stdout] 422 - } [INFO] [stdout] 418 + matches!(m.variant, MethodVariant::Method(_)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:460:65 [INFO] [stdout] | [INFO] [stdout] 460 | } else if let Some(inner) = ast::if_option_return_some_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap.rs:349:16 [INFO] [stdout] | [INFO] [stdout] 349 | if graph_snapshot.new_edges.iter().any(|x| *x == *edge) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `graph_snapshot.new_edges.contains(edge)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:480:47 [INFO] [stdout] | [INFO] [stdout] 480 | &conv_map.find_or_alloc_rust_type(&inner, src_id), [INFO] [stdout] | ^^^^^^ help: change this to: `inner` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:493:57 [INFO] [stdout] | [INFO] [stdout] 493 | } else if let Some(inner) = if_vec_return_elem_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:517:47 [INFO] [stdout] | [INFO] [stdout] 517 | &conv_map.find_or_alloc_rust_type(&inner.elem.deref(), src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `inner.elem.deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:556:9 [INFO] [stdout] | [INFO] [stdout] 556 | &rust_type, [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:573:65 [INFO] [stdout] | [INFO] [stdout] 573 | } else if let Some(inner) = ast::if_option_return_some_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:592:47 [INFO] [stdout] | [INFO] [stdout] 592 | &conv_map.find_or_alloc_rust_type(&inner, src_id), [INFO] [stdout] | ^^^^^^ help: change this to: `inner` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:604:57 [INFO] [stdout] | [INFO] [stdout] 604 | } else if let Some(inner) = if_vec_return_elem_type(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:618:85 [INFO] [stdout] | [INFO] [stdout] 618 | } else if let Some((inner_ok, _inner_err)) = ast::if_result_return_ok_err_types(&rust_type) { [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:640:47 [INFO] [stdout] | [INFO] [stdout] 640 | &conv_map.find_or_alloc_rust_type(&inner.elem.deref(), src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `inner.elem.deref()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/typemap.rs:755:62 [INFO] [stdout] | [INFO] [stdout] 755 | ... .replace(&ty_param_name, &*rust_ty.normalized_name.as_str()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `rust_ty.normalized_name.as_str()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap.rs:758:62 [INFO] [stdout] | [INFO] [stdout] 758 | ... .replace(&ty_param_name, &*class.name.to_string()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&class.name.to_string()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:769:55 [INFO] [stdout] | [INFO] [stdout] 769 | ast::check_if_smart_pointer_return_inner_type(&rust_type, "Mutex") [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/python/mod.rs:775:82 [INFO] [stdout] | [INFO] [stdout] 775 | } else if let Some(inner_ty) = ast::check_if_smart_pointer_return_inner_type(&rust_type, "Box") [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `rust_type` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/python/mod.rs:802:50 [INFO] [stdout] | [INFO] [stdout] 802 | conv_map.find_or_alloc_rust_type(&*reference.elem, src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^ help: try: `&reference.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/python/mod.rs:807:50 [INFO] [stdout] | [INFO] [stdout] 807 | conv_map.find_or_alloc_rust_type(&*reference.elem, src_id), [INFO] [stdout] | ^^^^^^^^^^^^^^^^ help: try: `&reference.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/typemap.rs:1024:9 [INFO] [stdout] | [INFO] [stdout] 1024 | mem::replace(&mut self.not_merged_data, vec![]) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut self.not_merged_data)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap.rs:1155:59 [INFO] [stdout] | [INFO] [stdout] 1155 | let mut ty_graph = TypeGraphSnapshot::new(conv_graph, &rust_names_map); [INFO] [stdout] | ^^^^^^^^^^^^^^^ help: change this to: `rust_names_map` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap.rs:1214:29 [INFO] [stdout] | [INFO] [stdout] 1214 | ... &ty_graph.conv_graph, [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ help: change this to: `ty_graph.conv_graph` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: large size difference between variants [INFO] [stdout] --> src/types.rs:93:1 [INFO] [stdout] | [INFO] [stdout] 93 | / pub(crate) enum FnArg { [INFO] [stdout] 94 | | SelfArg(Span, SelfTypeVariant), [INFO] [stdout] | | ------------------------------ the second-largest variant contains at least 13 bytes [INFO] [stdout] 95 | | Default(NamedArg), [INFO] [stdout] | | ----------------- the largest variant contains at least 392 bytes [INFO] [stdout] 96 | | } [INFO] [stdout] | |_^ the entire enum is at least 392 bytes [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stdout] help: consider boxing the large fields or introducing indirection in some other way to reduce the total size of the enum [INFO] [stdout] | [INFO] [stdout] 95 - Default(NamedArg), [INFO] [stdout] 95 + Default(Box), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/python/mod.rs:1266:18 [INFO] [stdout] | [INFO] [stdout] 1266 | Some(&*elem) [INFO] [stdout] | ^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] help: if you would like to reborrow, try removing `&*` [INFO] [stdout] | [INFO] [stdout] 1266 - Some(&*elem) [INFO] [stdout] 1266 + Some(elem) [INFO] [stdout] | [INFO] [stdout] help: if you would like to deref, try using `&**` [INFO] [stdout] | [INFO] [stdout] 1266 | Some(&**elem) [INFO] [stdout] | + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/types.rs:173:34 [INFO] [stdout] | [INFO] [stdout] 173 | acc.push_str(&x); [INFO] [stdout] | ^^ help: change this to: `x` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/ast/subst_map.rs:6:6 [INFO] [stdout] | [INFO] [stdout] 6 | impl<'a> PartialEq> for Ident { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] = note: `#[warn(clippy::extra_unused_lifetimes)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: manual implementation of `Option::map` [INFO] [stdout] --> src/typemap/ast/subst_map.rs:45:9 [INFO] [stdout] | [INFO] [stdout] 45 | / match self.inner.iter().position(|it| it.ident == k) { [INFO] [stdout] 46 | | Some(idx) => Some(self.inner[idx].ty.as_ref()), [INFO] [stdout] 47 | | None => None, [INFO] [stdout] 48 | | } [INFO] [stdout] | |_________^ help: try: `self.inner.iter().position(|it| it.ident == k).map(|idx| self.inner[idx].ty.as_ref())` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_map [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: doc list item overindented [INFO] [stdout] --> src/lib.rs:118:9 [INFO] [stdout] | [INFO] [stdout] 118 | /// for example android.support.annotation.NonNull [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using ` ` (2 spaces) [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_overindented_list_items [INFO] [stdout] = note: `#[warn(clippy::doc_overindented_list_items)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: doc list item overindented [INFO] [stdout] --> src/lib.rs:135:9 [INFO] [stdout] | [INFO] [stdout] 135 | /// for example for Android Studio [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using ` ` (2 spaces) [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_overindented_list_items [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: doc list item overindented [INFO] [stdout] --> src/lib.rs:136:9 [INFO] [stdout] | [INFO] [stdout] 136 | /// you should pass android.support.annotation [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using ` ` (2 spaces) [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_overindented_list_items [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this can be `std::io::Error::other(_)` [INFO] [stdout] --> src/lib.rs:640:22 [INFO] [stdout] | [INFO] [stdout] 640 | .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#io_other_error [INFO] [stdout] = note: `#[warn(clippy::io_other_error)]` on by default [INFO] [stdout] help: use `std::io::Error::other` [INFO] [stdout] | [INFO] [stdout] 640 - .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?; [INFO] [stdout] 640 + .map_err(|e| io::Error::other(format!("{}", e)))?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this can be `std::io::Error::other(_)` [INFO] [stdout] --> src/lib.rs:672:24 [INFO] [stdout] | [INFO] [stdout] 672 | Some(2) => Err(io::Error::new( [INFO] [stdout] | ________________________^ [INFO] [stdout] 673 | | io::ErrorKind::Other, [INFO] [stdout] 674 | | "Rustfmt parsing errors.".to_string(), [INFO] [stdout] 675 | | )), [INFO] [stdout] | |_________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#io_other_error [INFO] [stdout] help: use `std::io::Error::other` [INFO] [stdout] | [INFO] [stdout] 672 ~ Some(2) => Err(io::Error::other( [INFO] [stdout] 673 ~ "Rustfmt parsing errors.".to_string(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast.rs:721:41 [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec { [INFO] [stdout] | ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec<'_> { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast/subst_map.rs:33:28 [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem] { [INFO] [stdout] | ^^^^^ ^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | | | | [INFO] [stdout] | | | the same lifetime is hidden here [INFO] [stdout] | | the same lifetime is elided here [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem<'_>] { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/typemap_macro.rs:193:9 [INFO] [stdout] | [INFO] [stdout] 193 | &self, [INFO] [stdout] | ^^^^^ the lifetime is elided here [INFO] [stdout] ... [INFO] [stdout] 197 | ) -> Option [INFO] [stdout] | ^^^^^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 197 | ) -> Option> [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:128:32 [INFO] [stdout] | [INFO] [stdout] 128 | INTERNER.with(|interner| f(&mut *interner.borrow_mut())) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut interner.borrow_mut()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `if let .. else` expression looks like `matches!` macro [INFO] [stdout] --> src/typemap/ast.rs:147:17 [INFO] [stdout] | [INFO] [stdout] 147 | / if let syn::GenericArgument::Lifetime(_) = x { [INFO] [stdout] 148 | | false [INFO] [stdout] 149 | | } else { [INFO] [stdout] 150 | | true [INFO] [stdout] 151 | | } [INFO] [stdout] | |_________________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro [INFO] [stdout] help: use `matches!` directly [INFO] [stdout] | [INFO] [stdout] 147 - if let syn::GenericArgument::Lifetime(_) = x { [INFO] [stdout] 148 - false [INFO] [stdout] 149 - } else { [INFO] [stdout] 150 - true [INFO] [stdout] 151 - } [INFO] [stdout] 147 + !matches!(x, syn::GenericArgument::Lifetime(_)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.iter().nth()` on a slice [INFO] [stdout] --> src/typemap/ast.rs:318:18 [INFO] [stdout] | [INFO] [stdout] 318 | }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth [INFO] [stdout] = note: `#[warn(clippy::iter_nth)]` on by default [INFO] [stdout] help: `get` is equivalent but more concise [INFO] [stdout] | [INFO] [stdout] 318 - }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] 318 + }) = subst_map.as_slice().get(0).as_ref() [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:322:79 [INFO] [stdout] | [INFO] [stdout] 322 | (*from_foreigner_hint.as_str()).replace(&key.to_string(), &val_name); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `val_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:325:56 [INFO] [stdout] | [INFO] [stdout] 325 | != RustTypeS::make_unique_typename(&clean_from_ty, &foreign_name) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `clean_from_ty` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.iter().nth()` on a slice [INFO] [stdout] --> src/typemap/ast.rs:339:18 [INFO] [stdout] | [INFO] [stdout] 339 | }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth [INFO] [stdout] help: `get` is equivalent but more concise [INFO] [stdout] | [INFO] [stdout] 339 - }) = subst_map.as_slice().iter().nth(0).as_ref() [INFO] [stdout] 339 + }) = subst_map.as_slice().get(0).as_ref() [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:343:77 [INFO] [stdout] | [INFO] [stdout] 343 | (*to_foreigner_hint.as_str()).replace(&key.to_string(), &val_name); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `val_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this `map_or` can be simplified [INFO] [stdout] --> src/typemap/ast.rs:371:9 [INFO] [stdout] | [INFO] [stdout] 371 | others(val_name).map_or(true, |rt| !rt.implements.contains_subset(requires)) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or [INFO] [stdout] = note: `#[warn(clippy::unnecessary_map_or)]` on by default [INFO] [stdout] help: use `is_none_or` instead [INFO] [stdout] | [INFO] [stdout] 371 - others(val_name).map_or(true, |rt| !rt.implements.contains_subset(requires)) [INFO] [stdout] 371 + others(val_name).is_none_or(|rt| !rt.implements.contains_subset(requires)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this `map_or` can be simplified [INFO] [stdout] --> src/typemap/ast.rs:373:6 [INFO] [stdout] | [INFO] [stdout] 373 | !trait_bounds [INFO] [stdout] | ______^ [INFO] [stdout] 374 | | .iter() [INFO] [stdout] 375 | | .position(|it| it.ty_param.as_ref() == subst_ident) [INFO] [stdout] 376 | | .map_or(false, traits_bound_not_match) [INFO] [stdout] | |______________________________________________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or [INFO] [stdout] help: use `is_some_and` instead [INFO] [stdout] | [INFO] [stdout] 376 - .map_or(false, traits_bound_not_match) [INFO] [stdout] 376 + .is_some_and(traits_bound_not_match) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:400:42 [INFO] [stdout] | [INFO] [stdout] 400 | is_second_subst_of_first(&*mut_ty1.elem, &*mut_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&mut_ty1.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:400:58 [INFO] [stdout] | [INFO] [stdout] 400 | is_second_subst_of_first(&*mut_ty1.elem, &*mut_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&mut_ty2.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:408:42 [INFO] [stdout] | [INFO] [stdout] 408 | is_second_subst_of_first(&*ptr_ty1.elem, &*ptr_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&ptr_ty1.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:408:58 [INFO] [stdout] | [INFO] [stdout] 408 | is_second_subst_of_first(&*ptr_ty1.elem, &*ptr_ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `&ptr_ty2.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:412:38 [INFO] [stdout] | [INFO] [stdout] 412 | is_second_subst_of_first(&*ty1.elem, &*ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^ help: try: `&ty1.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/ast.rs:412:50 [INFO] [stdout] | [INFO] [stdout] 412 | is_second_subst_of_first(&*ty1.elem, &*ty2.elem, subst_map) [INFO] [stdout] | ^^^^^^^^^^ help: try: `&ty2.elem` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/ast.rs:698:6 [INFO] [stdout] | [INFO] [stdout] 698 | impl<'a> PartialEq for TyParamRef<'_> { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/ast.rs:704:6 [INFO] [stdout] | [INFO] [stdout] 704 | impl<'a> AsRef for TyParamRef<'_> { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:708:35 [INFO] [stdout] | [INFO] [stdout] 708 | TyParamRef::Own(x) => &x, [INFO] [stdout] | ^^ help: change this to: `x` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:739:45 [INFO] [stdout] | [INFO] [stdout] 739 | ret_elem.trait_names.insert(&trait_path); [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `trait_path` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:756:25 [INFO] [stdout] | [INFO] [stdout] 756 | &normalize_type(bounded_ty), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `normalize_type(bounded_ty)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:768:53 [INFO] [stdout] | [INFO] [stdout] 768 | ret_elem.trait_names.insert(&trait_path); [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `trait_path` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/ast.rs:853:25 [INFO] [stdout] | [INFO] [stdout] 853 | self.0.push(&lifetime); [INFO] [stdout] | ^^^^^^^^^ help: change this to: `lifetime` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: stripping a prefix manually [INFO] [stdout] --> src/typemap/parse.rs:334:33 [INFO] [stdout] | [INFO] [stdout] 334 | ... &val[1..] [INFO] [stdout] | ^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: the prefix was tested here [INFO] [stdout] --> src/typemap/parse.rs:333:39 [INFO] [stdout] | [INFO] [stdout] 333 | ... let val = if val.starts_with('"') { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip [INFO] [stdout] = note: `#[warn(clippy::manual_strip)]` on by default [INFO] [stdout] help: try using the `strip_prefix` method [INFO] [stdout] | [INFO] [stdout] 333 ~ let val = if let Some() = val.strip_prefix('"') { [INFO] [stdout] 334 ~ [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: stripping a suffix manually [INFO] [stdout] --> src/typemap/parse.rs:339:33 [INFO] [stdout] | [INFO] [stdout] 339 | ... &val[..val.len() - 1] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: the suffix was tested here [INFO] [stdout] --> src/typemap/parse.rs:338:39 [INFO] [stdout] | [INFO] [stdout] 338 | ... let val = if val.ends_with('"') { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip [INFO] [stdout] help: try using the `strip_suffix` method [INFO] [stdout] | [INFO] [stdout] 338 ~ let val = if let Some() = val.strip_suffix('"') { [INFO] [stdout] 339 ~ [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:341:33 [INFO] [stdout] | [INFO] [stdout] 341 | ... &val [INFO] [stdout] | ^^^^ help: change this to: `val` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> src/typemap/parse.rs:388:29 [INFO] [stdout] | [INFO] [stdout] 388 | fn get_swig_code_from_attrs<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] 389 | item_span: SourceIdSpan, [INFO] [stdout] 390 | swig_code_attr_name: &'a str, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] = note: `#[warn(clippy::needless_lifetimes)]` on by default [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 388 ~ fn get_swig_code_from_attrs<'b>( [INFO] [stdout] 389 | item_span: SourceIdSpan, [INFO] [stdout] 390 ~ swig_code_attr_name: &str, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:404:55 [INFO] [stdout] | [INFO] [stdout] 404 | validate_code_template((item_span.0, sp), &conv_code_template.as_str())?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `conv_code_template.as_str()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:492:17 [INFO] [stdout] | [INFO] [stdout] 492 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:498:17 [INFO] [stdout] | [INFO] [stdout] 498 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:576:17 [INFO] [stdout] | [INFO] [stdout] 576 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:582:17 [INFO] [stdout] | [INFO] [stdout] 582 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:641:74 [INFO] [stdout] | [INFO] [stdout] 641 | get_swig_code_from_attrs((src_id, item_macro.span()), SWIG_CODE, &swig_attrs)?; [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:664:13 [INFO] [stdout] | [INFO] [stdout] 664 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/parse.rs:670:13 [INFO] [stdout] | [INFO] [stdout] 670 | &swig_attrs, [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `swig_attrs` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/typemap/parse.rs:758:49 [INFO] [stdout] | [INFO] [stdout] 758 | err.span_note((src_id, attrs[0].1), &format!("First {}", attr_name)); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `format!("First {}", attr_name)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'b [INFO] [stdout] --> src/typemap/parse.rs:812:37 [INFO] [stdout] | [INFO] [stdout] 812 | fn unpack_first_associated_type<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] 813 | items: &'a [syn::ImplItem], [INFO] [stdout] 814 | assoc_type_name: &'b str, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 812 ~ fn unpack_first_associated_type<'a>( [INFO] [stdout] 813 | items: &'a [syn::ImplItem], [INFO] [stdout] 814 ~ assoc_type_name: &str, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: redundant field names in struct initialization [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:5437 [INFO] [stdout] | [INFO] [stdout] 1 | ...null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . i... [INFO] [stdout] | ^^^^^^^^^^^^^ help: replace it with: `chars` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stdout] = note: `#[warn(clippy::redundant_field_names)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: redundant field names in struct initialization [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:5453 [INFO] [stdout] | [INFO] [stdout] 1 | ... ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { l... [INFO] [stdout] | ^^^^^^^^^ help: replace it with: `env` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this looks like an `else if` but the `else` is missing [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:7833 [INFO] [stdout] | [INFO] [stdout] 1 | ...env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv... [INFO] [stdout] | ^ [INFO] [stdout] | [INFO] [stdout] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_else [INFO] [stdout] = note: `#[warn(clippy::possible_missing_else)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/ty.rs:109:13 [INFO] [stdout] | [INFO] [stdout] 109 | if !self.inner.iter().any(|it| x == *it) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `self.inner.contains(&x)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] = note: `#[warn(clippy::manual_contains)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: fields `ignore`, `no_run`, `should_panic`, and `template` are never read [INFO] [stdout] --> tests/test_code_in_readme.rs:69:5 [INFO] [stdout] | [INFO] [stdout] 66 | struct Test { [INFO] [stdout] | ---- fields in this struct [INFO] [stdout] ... [INFO] [stdout] 69 | ignore: bool, [INFO] [stdout] | ^^^^^^ [INFO] [stdout] 70 | no_run: bool, [INFO] [stdout] | ^^^^^^ [INFO] [stdout] 71 | should_panic: bool, [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] 72 | template: Option, [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `Test` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> tests/test_code_in_readme.rs:22:32 [INFO] [stdout] | [INFO] [stdout] 22 | fs::create_dir_all(&tmp_dir.path().join(&test.name)).unwrap(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `tmp_dir.path().join(&test.name)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] = note: `#[warn(clippy::needless_borrows_for_generic_args)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/typemap_macro/parse.rs:347:25 [INFO] [stdout] | [INFO] [stdout] 347 | if !f.attrs.iter().any(|a| *a == mangle_attr) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `f.attrs.contains(&mangle_attr)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/typemap_macro/parse.rs:380:5 [INFO] [stdout] | [INFO] [stdout] 380 | attrs.iter().any(|a| *a == repr_c_attr) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `attrs.contains(&repr_c_attr)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap/typemap_macro/parse.rs:564:16 [INFO] [stdout] | [INFO] [stdout] 564 | if temporary_ids.iter().any(|x| *x == var_name) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `temporary_ids.contains(&var_name)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:17:13 [INFO] [stdout] | [INFO] [stdout] 17 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] = note: `#[warn(clippy::nonminimal_bool)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:62:13 [INFO] [stdout] | [INFO] [stdout] 62 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:137:13 [INFO] [stdout] | [INFO] [stdout] 137 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:157:13 [INFO] [stdout] | [INFO] [stdout] 157 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: casting raw pointers to the same type and constness is unnecessary (`*mut T` -> `*mut T`) [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:11657 [INFO] [stdout] | [INFO] [stdout] 1 | ...j , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () ... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `jlong_to_pointer (ptr)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast [INFO] [stdout] = note: `#[warn(clippy::unnecessary_cast)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:213:13 [INFO] [stdout] | [INFO] [stdout] 213 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:21533 [INFO] [stdout] | [INFO] [stdout] 1 | ...= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; ... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] = note: `#[warn(clippy::legacy_numeric_constants)]` on by default [INFO] [stdout] = note: this warning originates in the macro `define_array_handling_code` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize::MAX as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:260:13 [INFO] [stdout] | [INFO] [stdout] 260 | assert!(!rule.if_simple_rtype_ftype_map().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:261:13 [INFO] [stdout] | [INFO] [stdout] 261 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:334:13 [INFO] [stdout] | [INFO] [stdout] 334 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: usage of a legacy numeric method [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:21760 [INFO] [stdout] | [INFO] [stdout] 1 | ...= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; ... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants [INFO] [stdout] = note: this warning originates in the macro `define_array_handling_code` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: use the associated constant instead [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize::MAX as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:372:13 [INFO] [stdout] | [INFO] [stdout] 372 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this boolean expression can be simplified [INFO] [stdout] --> src/typemap/typemap_macro/tests.rs:416:13 [INFO] [stdout] | [INFO] [stdout] 416 | assert!(!rule.if_simple_rtype_ftype_map_no_lang_backend().is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rule.if_simple_rtype_ftype_map_no_lang_backend().is_none()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:24415 [INFO] [stdout] | [INFO] [stdout] 1 | ... Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; ... [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] = note: `#[warn(clippy::borrow_deref_ref)]` on by default [INFO] [stdout] help: if you would like to reborrow, try removing `&*` [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] help: if you would like to deref, try using `&**` [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { &**self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:24700 [INFO] [stdout] | [INFO] [stdout] 1 | ...elf { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEn... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] = note: `#[warn(clippy::needless_lifetimes)]` on by default [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl SwigInto < jintArray > for & [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:25129 [INFO] [stdout] | [INFO] [stdout] 1 | ...f { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEn... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl SwigInto < jlongArray > for & [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: non-canonical implementation of `partial_cmp` on an `Ord` type [INFO] [stdout] --> src/typemap/typemap_macro.rs:106:1 [INFO] [stdout] | [INFO] [stdout] 106 | / impl PartialOrd for ModuleName { [INFO] [stdout] 107 | | fn partial_cmp(&self, other: &Self) -> Option { [INFO] [stdout] 108 | | Some(self.name.cmp(&other.name)) [INFO] [stdout] 109 | | } [INFO] [stdout] 110 | | } [INFO] [stdout] | |_^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#non_canonical_partial_ord_impl [INFO] [stdout] = note: `#[warn(clippy::non_canonical_partial_ord_impl)]` on by default [INFO] [stdout] help: change this to [INFO] [stdout] | [INFO] [stdout] 107 - fn partial_cmp(&self, other: &Self) -> Option { [INFO] [stdout] 108 - Some(self.name.cmp(&other.name)) [INFO] [stdout] 109 - } [INFO] [stdout] 107 + fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:25566 [INFO] [stdout] | [INFO] [stdout] 1 | ... { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIE... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl SwigInto < jfloatArray > for & [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:26011 [INFO] [stdout] | [INFO] [stdout] 1 | ... JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIE... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl SwigInto < jdoubleArray > for & [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:26448 [INFO] [stdout] | [INFO] [stdout] 1 | ...f { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl SwigInto < jbyteArray > for & [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: accessing first element with `self.ftype_left_to_right.get(0)` [INFO] [stdout] --> src/typemap/typemap_macro.rs:141:13 [INFO] [stdout] | [INFO] [stdout] 141 | self.ftype_left_to_right.get(0), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `self.ftype_left_to_right.first()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_first [INFO] [stdout] = note: `#[warn(clippy::get_first)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/typemap_macro.rs:251:71 [INFO] [stdout] | [INFO] [stdout] 251 | build_generic_aliases(self.src_id, &self.generic_aliases, ¶m_map, expander)?; [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `param_map` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:26884 [INFO] [stdout] | [INFO] [stdout] 1 | ... { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIE... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl SwigInto < jshortArray > for & [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'b [INFO] [stdout] --> src/typemap/typemap_macro.rs:479:30 [INFO] [stdout] | [INFO] [stdout] 479 | fn build_generic_aliases<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] ... [INFO] [stdout] 482 | param_map: &'b TyParamsSubstMap, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 479 ~ fn build_generic_aliases<'a>( [INFO] [stdout] 480 | src_id: SourceId, [INFO] [stdout] 481 | generic_aliases: &'a [GenericAlias], [INFO] [stdout] 482 ~ param_map: &TyParamsSubstMap, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:27786 [INFO] [stdout] | [INFO] [stdout] 1 | ... ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self)... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T > SwigDeref for & Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: called `.as_ref().map(String::as_str)` on an `Option` value [INFO] [stdout] --> src/typemap/typemap_macro.rs:557:17 [INFO] [stdout] | [INFO] [stdout] 557 | / opt_arg [INFO] [stdout] 558 | | .as_ref() [INFO] [stdout] 559 | | .map(syn::Ident::to_string) [INFO] [stdout] 560 | | .as_ref() [INFO] [stdout] 561 | | .map(String::as_str), [INFO] [stdout] | |________________________________________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref [INFO] [stdout] help: consider using as_deref [INFO] [stdout] | [INFO] [stdout] 557 ~ opt_arg [INFO] [stdout] 558 + .as_ref() [INFO] [stdout] 559 ~ .map(syn::Ident::to_string).as_deref(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:583:15 [INFO] [stdout] | [INFO] [stdout] 583 | match (&code[prev_pos..]).find(char::is_alphabetic) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[prev_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:592:27 [INFO] [stdout] | [INFO] [stdout] 592 | match (&code[prev_pos..]).find(|ch: char| !ch.is_alphabetic()) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[prev_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:617:33 [INFO] [stdout] | [INFO] [stdout] 617 | let mut next_pos = id_end + (&code[id_end..]).find(|ch: char| !ch.is_whitespace())?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ help: change this to: `code[id_end..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:622:27 [INFO] [stdout] | [INFO] [stdout] 622 | next_pos = next_pos + (&code[next_pos..]).find(|ch: char| !ch.is_whitespace())?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[next_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:630:22 [INFO] [stdout] | [INFO] [stdout] 630 | for (idx, ch) in (&code[next_pos..]).chars().enumerate() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ help: change this to: `code[next_pos..]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:644:29 [INFO] [stdout] | [INFO] [stdout] 644 | let params: Vec<&str> = (&code[cnt_start..cnt_end]) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `code[cnt_start..cnt_end]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this `map_or` can be simplified [INFO] [stdout] --> tests/test_expectations.rs:461:28 [INFO] [stdout] | [INFO] [stdout] 461 | .any(|ext| path.path().to_str().map_or(false, |x| x.ends_with(ext))) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or [INFO] [stdout] = note: `#[warn(clippy::unnecessary_map_or)]` on by default [INFO] [stdout] help: use `is_some_and` instead [INFO] [stdout] | [INFO] [stdout] 461 - .any(|ext| path.path().to_str().map_or(false, |x| x.ends_with(ext))) [INFO] [stdout] 461 + .any(|ext| path.path().to_str().is_some_and(|x| x.ends_with(ext))) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:29291 [INFO] [stdout] | [INFO] [stdout] 1 | ... x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> ... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl SwigInto < String > for & str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> tests/test_expectations.rs:551:24 [INFO] [stdout] | [INFO] [stdout] 551 | parse_code(&test_name, Source::Path(&test_case), lang).expect("parse_code failed"); [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `test_name` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] = note: `#[warn(clippy::needless_borrow)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> tests/test_expectations.rs:551:49 [INFO] [stdout] | [INFO] [stdout] 551 | parse_code(&test_name, Source::Path(&test_case), lang).expect("parse_code failed"); [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `test_case` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> tests/test_expectations.rs:561:45 [INFO] [stdout] | [INFO] [stdout] 561 | let rust_cpp_expectation = new_path(&test_case, rust_ext); [INFO] [stdout] | ^^^^^^^^^^ help: change this to: `test_case` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: redundant closure [INFO] [stdout] --> tests/test_expectations.rs:567:22 [INFO] [stdout] | [INFO] [stdout] 567 | .map(|v| rustfmt_without_errors(v)) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `rustfmt_without_errors` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure [INFO] [stdout] = note: `#[warn(clippy::redundant_closure)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression borrows a value the compiler would automatically borrow [INFO] [stdout] --> src/typemap/typemap_macro.rs:913:26 [INFO] [stdout] | [INFO] [stdout] 913 | let alias_name = (&type_name[0..type_name.len() - 3]).trim(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `type_name[0..type_name.len() - 3]` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: large size difference between variants [INFO] [stdout] --> src/typemap/typemap_macro.rs:1003:1 [INFO] [stdout] | [INFO] [stdout] 1003 | / enum TyValueOrRef<'a> { [INFO] [stdout] 1004 | | Value(Type), [INFO] [stdout] | | ----------- the largest variant contains at least 352 bytes [INFO] [stdout] 1005 | | Ref(&'a Type), [INFO] [stdout] | | ------------- the second-largest variant contains at least 8 bytes [INFO] [stdout] 1006 | | } [INFO] [stdout] | |_^ the entire enum is at least 352 bytes [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stdout] = note: `#[warn(clippy::large_enum_variant)]` on by default [INFO] [stdout] help: consider boxing the large fields or introducing indirection in some other way to reduce the total size of the enum [INFO] [stdout] | [INFO] [stdout] 1004 - Value(Type), [INFO] [stdout] 1004 + Value(Box), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this lifetime isn't used in the impl [INFO] [stdout] --> src/typemap/typemap_macro.rs:1008:6 [INFO] [stdout] | [INFO] [stdout] 1008 | impl<'a> AsRef for TyValueOrRef<'_> { [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> src/typemap/typemap_macro.rs:1017:20 [INFO] [stdout] | [INFO] [stdout] 1017 | fn find_type_param<'a, 'b>( [INFO] [stdout] | ^^ [INFO] [stdout] 1018 | param_map: &'b TyParamsSubstMap, [INFO] [stdout] 1019 | param: &'a str, [INFO] [stdout] | ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1017 ~ fn find_type_param<'b>( [INFO] [stdout] 1018 | param_map: &'b TyParamsSubstMap, [INFO] [stdout] 1019 ~ param: &str, [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/cpp-include.rs:1:3301 [INFO] [stdout] | [INFO] [stdout] 1 | ... ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self)... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } mod swig_foreign_types_map { } foreign_typemap ! ((r_type) :: std :: os :: raw :: c_char ; (f_type) "char" ;) ; foreign_typemap ! ((r_type) :: std :: os :: raw :: c_int ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) f32 ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) f64 ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) i8 ; (f_type , req_modules = [""]) "int8_t" ;) ; foreign_typemap ! ((r_type) u8 ; (f_type , req_modules = [""]) "uint8_t" ;) ; foreign_typemap ! ((r_type) i16 ; (f_type , req_modules = [""]) "int16_t" ;) ; foreign_typemap ! ((r_type) u16 ; (f_type , req_modules = [""]) "uint16_t" ;) ; foreign_typemap ! ((r_type) i32 ; (f_type , req_modules = [""]) "int32_t" ;) ; foreign_typemap ! ((r_type) u32 ; (f_type , req_modules = [""]) "uint32_t" ;) ; foreign_typemap ! ((r_type) i64 ; (f_type , req_modules = [""]) "int64_t" ;) ; foreign_typemap ! ((r_type) u64 ; (f_type , req_modules = [""]) "uint64_t" ;) ; foreign_typemap ! ((r_type) usize ; (f_type , req_modules = [""]) "uintptr_t" ;) ; foreign_typemap ! ((r_type) isize ; (f_type , req_modules = [""]) "intptr_t" ;) ; # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (dead_code)] pub trait SwigForeignClass { fn c_class_name () -> * const :: std :: os :: raw :: c_char ; fn box_object (x : Self) -> * mut :: std :: os :: raw :: c_void ; fn unbox_object (p : * mut :: std :: os :: raw :: c_void) -> Self ; } # [allow (dead_code)] pub trait SwigForeignEnum { fn as_u32 (& self) -> u32 ; fn from_u32 (_ : u32) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (dead_code)] # [repr (C)] # [derive (Clone , Copy)] pub struct CRustStrView { data : * const :: std :: os :: raw :: c_char , len : usize , } # [allow (dead_code)] impl CRustStrView { fn from_str (s : & str) -> CRustStrView { CRustStrView { data : s . as_ptr () as * const :: std :: os :: raw :: c_char , len : s . len () , } } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T >) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < 'a > SwigInto < & 'a Path > for & 'a str { fn swig_into (self) -> & 'a Path { Path :: new (self) } } # [allow (dead_code)] # [repr (C)] # [derive (Copy , Clone)] pub struct CRustString { data : * const :: std :: os :: raw :: c_char , len : usize , capacity : usize , } # [allow (dead_code)] impl CRustString { pub fn from_string (s : String) -> CRustString { let data = s . as_ptr () as * const :: std :: os :: raw :: c_char ; let len = s . len () ; let capacity = s . capacity () ; :: std :: mem :: forget (s) ; CRustString { data , len , capacity , } } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self) -> String { self . into () } } impl < T : SwigForeignEnum > SwigFrom < T > for u32 { fn swig_from (x : T) -> u32 { x . as_u32 () } } impl < T : SwigForeignEnum > SwigFrom < u32 > for T { fn swig_from (x : u32) -> T { T :: from_u32 (x) } } foreign_typemap ! ((r_type) * mut :: std :: os :: raw :: c_void ; (f_type) "void *" ;) ; foreign_typemap ! ((r_type) * const :: std :: os :: raw :: c_void ; (f_type) "/*const*/void *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * const T ; (f_type) "const swig_f_type!(T) *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * mut T ; (f_type) "swig_f_type!(T) *" ;) ; foreign_typemap ! (generic_alias ! (CFnTwoArgsPtr = swig_concat_idents ! (c_fn_ , swig_i_type ! (T1) , swig_i_type ! (T1) , _t)) ; foreign_code ! (module = "CFnTwoArgsPtr!().h" ; r##" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } mod swig_foreign_types_map { } foreign_typemap ! ((r_type) :: std :: os :: raw :: c_char ; (f_type) "char" ;) ; foreign_typemap ! ((r_type) :: std :: os :: raw :: c_int ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) f32 ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) f64 ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) i8 ; (f_type , req_modules = [""]) "int8_t" ;) ; foreign_typemap ! ((r_type) u8 ; (f_type , req_modules = [""]) "uint8_t" ;) ; foreign_typemap ! ((r_type) i16 ; (f_type , req_modules = [""]) "int16_t" ;) ; foreign_typemap ! ((r_type) u16 ; (f_type , req_modules = [""]) "uint16_t" ;) ; foreign_typemap ! ((r_type) i32 ; (f_type , req_modules = [""]) "int32_t" ;) ; foreign_typemap ! ((r_type) u32 ; (f_type , req_modules = [""]) "uint32_t" ;) ; foreign_typemap ! ((r_type) i64 ; (f_type , req_modules = [""]) "int64_t" ;) ; foreign_typemap ! ((r_type) u64 ; (f_type , req_modules = [""]) "uint64_t" ;) ; foreign_typemap ! ((r_type) usize ; (f_type , req_modules = [""]) "uintptr_t" ;) ; foreign_typemap ! ((r_type) isize ; (f_type , req_modules = [""]) "intptr_t" ;) ; # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (dead_code)] pub trait SwigForeignClass { fn c_class_name () -> * const :: std :: os :: raw :: c_char ; fn box_object (x : Self) -> * mut :: std :: os :: raw :: c_void ; fn unbox_object (p : * mut :: std :: os :: raw :: c_void) -> Self ; } # [allow (dead_code)] pub trait SwigForeignEnum { fn as_u32 (& self) -> u32 ; fn from_u32 (_ : u32) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (dead_code)] # [repr (C)] # [derive (Clone , Copy)] pub struct CRustStrView { data : * const :: std :: os :: raw :: c_char , len : usize , } # [allow (dead_code)] impl CRustStrView { fn from_str (s : & str) -> CRustStrView { CRustStrView { data : s . as_ptr () as * const :: std :: os :: raw :: c_char , len : s . len () , } } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T >) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T > SwigDeref for & Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < 'a > SwigInto < & 'a Path > for & 'a str { fn swig_into (self) -> & 'a Path { Path :: new (self) } } # [allow (dead_code)] # [repr (C)] # [derive (Copy , Clone)] pub struct CRustString { data : * const :: std :: os :: raw :: c_char , len : usize , capacity : usize , } # [allow (dead_code)] impl CRustString { pub fn from_string (s : String) -> CRustString { let data = s . as_ptr () as * const :: std :: os :: raw :: c_char ; let len = s . len () ; let capacity = s . capacity () ; :: std :: mem :: forget (s) ; CRustString { data , len , capacity , } } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self) -> String { self . into () } } impl < T : SwigForeignEnum > SwigFrom < T > for u32 { fn swig_from (x : T) -> u32 { x . as_u32 () } } impl < T : SwigForeignEnum > SwigFrom < u32 > for T { fn swig_from (x : u32) -> T { T :: from_u32 (x) } } foreign_typemap ! ((r_type) * mut :: std :: os :: raw :: c_void ; (f_type) "void *" ;) ; foreign_typemap ! ((r_type) * const :: std :: os :: raw :: c_void ; (f_type) "/*const*/void *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * const T ; (f_type) "const swig_f_type!(T) *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * mut T ; (f_type) "swig_f_type!(T) *" ;) ; foreign_typemap ! (generic_alias ! (CFnTwoArgsPtr = swig_concat_idents ! (c_fn_ , swig_i_type ! (T1) , swig_i_type ! (T1) , _t)) ; foreign_code ! (module = "CFnTwoArgsPtr!().h" ; r##" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the following explicit lifetimes could be elided: 'a [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/cpp-include.rs:1:4729 [INFO] [stdout] | [INFO] [stdout] 1 | ...stString { data , len , capacity , } } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self) -> String { self . int... [INFO] [stdout] | ^^ ^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stdout] help: elide the lifetimes [INFO] [stdout] | [INFO] [stdout] 1 - macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } mod swig_foreign_types_map { } foreign_typemap ! ((r_type) :: std :: os :: raw :: c_char ; (f_type) "char" ;) ; foreign_typemap ! ((r_type) :: std :: os :: raw :: c_int ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) f32 ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) f64 ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) i8 ; (f_type , req_modules = [""]) "int8_t" ;) ; foreign_typemap ! ((r_type) u8 ; (f_type , req_modules = [""]) "uint8_t" ;) ; foreign_typemap ! ((r_type) i16 ; (f_type , req_modules = [""]) "int16_t" ;) ; foreign_typemap ! ((r_type) u16 ; (f_type , req_modules = [""]) "uint16_t" ;) ; foreign_typemap ! ((r_type) i32 ; (f_type , req_modules = [""]) "int32_t" ;) ; foreign_typemap ! ((r_type) u32 ; (f_type , req_modules = [""]) "uint32_t" ;) ; foreign_typemap ! ((r_type) i64 ; (f_type , req_modules = [""]) "int64_t" ;) ; foreign_typemap ! ((r_type) u64 ; (f_type , req_modules = [""]) "uint64_t" ;) ; foreign_typemap ! ((r_type) usize ; (f_type , req_modules = [""]) "uintptr_t" ;) ; foreign_typemap ! ((r_type) isize ; (f_type , req_modules = [""]) "intptr_t" ;) ; # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (dead_code)] pub trait SwigForeignClass { fn c_class_name () -> * const :: std :: os :: raw :: c_char ; fn box_object (x : Self) -> * mut :: std :: os :: raw :: c_void ; fn unbox_object (p : * mut :: std :: os :: raw :: c_void) -> Self ; } # [allow (dead_code)] pub trait SwigForeignEnum { fn as_u32 (& self) -> u32 ; fn from_u32 (_ : u32) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (dead_code)] # [repr (C)] # [derive (Clone , Copy)] pub struct CRustStrView { data : * const :: std :: os :: raw :: c_char , len : usize , } # [allow (dead_code)] impl CRustStrView { fn from_str (s : & str) -> CRustStrView { CRustStrView { data : s . as_ptr () as * const :: std :: os :: raw :: c_char , len : s . len () , } } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T >) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < 'a > SwigInto < & 'a Path > for & 'a str { fn swig_into (self) -> & 'a Path { Path :: new (self) } } # [allow (dead_code)] # [repr (C)] # [derive (Copy , Clone)] pub struct CRustString { data : * const :: std :: os :: raw :: c_char , len : usize , capacity : usize , } # [allow (dead_code)] impl CRustString { pub fn from_string (s : String) -> CRustString { let data = s . as_ptr () as * const :: std :: os :: raw :: c_char ; let len = s . len () ; let capacity = s . capacity () ; :: std :: mem :: forget (s) ; CRustString { data , len , capacity , } } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self) -> String { self . into () } } impl < T : SwigForeignEnum > SwigFrom < T > for u32 { fn swig_from (x : T) -> u32 { x . as_u32 () } } impl < T : SwigForeignEnum > SwigFrom < u32 > for T { fn swig_from (x : u32) -> T { T :: from_u32 (x) } } foreign_typemap ! ((r_type) * mut :: std :: os :: raw :: c_void ; (f_type) "void *" ;) ; foreign_typemap ! ((r_type) * const :: std :: os :: raw :: c_void ; (f_type) "/*const*/void *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * const T ; (f_type) "const swig_f_type!(T) *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * mut T ; (f_type) "swig_f_type!(T) *" ;) ; foreign_typemap ! (generic_alias ! (CFnTwoArgsPtr = swig_concat_idents ! (c_fn_ , swig_i_type ! (T1) , swig_i_type ! (T1) , _t)) ; foreign_code ! (module = "CFnTwoArgsPtr!().h" ; r##" [INFO] [stdout] 1 + macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } mod swig_foreign_types_map { } foreign_typemap ! ((r_type) :: std :: os :: raw :: c_char ; (f_type) "char" ;) ; foreign_typemap ! ((r_type) :: std :: os :: raw :: c_int ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) f32 ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) f64 ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) i8 ; (f_type , req_modules = [""]) "int8_t" ;) ; foreign_typemap ! ((r_type) u8 ; (f_type , req_modules = [""]) "uint8_t" ;) ; foreign_typemap ! ((r_type) i16 ; (f_type , req_modules = [""]) "int16_t" ;) ; foreign_typemap ! ((r_type) u16 ; (f_type , req_modules = [""]) "uint16_t" ;) ; foreign_typemap ! ((r_type) i32 ; (f_type , req_modules = [""]) "int32_t" ;) ; foreign_typemap ! ((r_type) u32 ; (f_type , req_modules = [""]) "uint32_t" ;) ; foreign_typemap ! ((r_type) i64 ; (f_type , req_modules = [""]) "int64_t" ;) ; foreign_typemap ! ((r_type) u64 ; (f_type , req_modules = [""]) "uint64_t" ;) ; foreign_typemap ! ((r_type) usize ; (f_type , req_modules = [""]) "uintptr_t" ;) ; foreign_typemap ! ((r_type) isize ; (f_type , req_modules = [""]) "intptr_t" ;) ; # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (dead_code)] pub trait SwigForeignClass { fn c_class_name () -> * const :: std :: os :: raw :: c_char ; fn box_object (x : Self) -> * mut :: std :: os :: raw :: c_void ; fn unbox_object (p : * mut :: std :: os :: raw :: c_void) -> Self ; } # [allow (dead_code)] pub trait SwigForeignEnum { fn as_u32 (& self) -> u32 ; fn from_u32 (_ : u32) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (dead_code)] # [repr (C)] # [derive (Clone , Copy)] pub struct CRustStrView { data : * const :: std :: os :: raw :: c_char , len : usize , } # [allow (dead_code)] impl CRustStrView { fn from_str (s : & str) -> CRustStrView { CRustStrView { data : s . as_ptr () as * const :: std :: os :: raw :: c_char , len : s . len () , } } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T >) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T >) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < 'a > SwigInto < & 'a Path > for & 'a str { fn swig_into (self) -> & 'a Path { Path :: new (self) } } # [allow (dead_code)] # [repr (C)] # [derive (Copy , Clone)] pub struct CRustString { data : * const :: std :: os :: raw :: c_char , len : usize , capacity : usize , } # [allow (dead_code)] impl CRustString { pub fn from_string (s : String) -> CRustString { let data = s . as_ptr () as * const :: std :: os :: raw :: c_char ; let len = s . len () ; let capacity = s . capacity () ; :: std :: mem :: forget (s) ; CRustString { data , len , capacity , } } } impl SwigInto < String > for & str { fn swig_into (self) -> String { self . into () } } impl < T : SwigForeignEnum > SwigFrom < T > for u32 { fn swig_from (x : T) -> u32 { x . as_u32 () } } impl < T : SwigForeignEnum > SwigFrom < u32 > for T { fn swig_from (x : u32) -> T { T :: from_u32 (x) } } foreign_typemap ! ((r_type) * mut :: std :: os :: raw :: c_void ; (f_type) "void *" ;) ; foreign_typemap ! ((r_type) * const :: std :: os :: raw :: c_void ; (f_type) "/*const*/void *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * const T ; (f_type) "const swig_f_type!(T) *" ;) ; foreign_typemap ! ((r_type) < T : SwigTypeIsReprC > * mut T ; (f_type) "swig_f_type!(T) *" ;) ; foreign_typemap ! (generic_alias ! (CFnTwoArgsPtr = swig_concat_idents ! (c_fn_ , swig_i_type ! (T1) , swig_i_type ! (T1) , _t)) ; foreign_code ! (module = "CFnTwoArgsPtr!().h" ; r##" [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: calling `push_str()` using a single-character string literal [INFO] [stdout] --> src/typemap/typemap_macro.rs:1152:25 [INFO] [stdout] | [INFO] [stdout] 1152 | out.push_str(")"); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `out.push(')')` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-f57a9d6029cb1019/out/jni-include.rs:1:7405 [INFO] [stdout] | [INFO] [stdout] 1 | ... Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIE... [INFO] [stdout] | ^^^^^^ ^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 1 | macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder<'_> { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/utils.rs:235:80 [INFO] [stdout] | [INFO] [stdout] 235 | if let Some(inner_ty) = check_if_smart_pointer_return_inner_type(from, *smart_pointer) { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/utils.rs:251:80 [INFO] [stdout] | [INFO] [stdout] 251 | if let Some(inner_ty) = check_if_smart_pointer_return_inner_type(from, *smart_pointer) { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap/utils.rs:254:57 [INFO] [stdout] | [INFO] [stdout] 254 | let smart_pointer_ty: Type = syn::parse_str(&smart_pointer).unwrap_or_else(|err| { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: change this to: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap/utils.rs:284:59 [INFO] [stdout] | [INFO] [stdout] 284 | if check_if_smart_pointer_return_inner_type(from, *smart_pointer).is_some() { [INFO] [stdout] | ^^^^^^^^^^^^^^ help: try: `smart_pointer` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the borrowed expression implements the required traits [INFO] [stdout] --> src/typemap/utils.rs:360:32 [INFO] [stdout] | [INFO] [stdout] 360 | let entries = fs::read_dir(&output_dir) [INFO] [stdout] | ^^^^^^^^^^^ help: change this to: `output_dir` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: stripping a prefix manually [INFO] [stdout] --> src/typemap.rs:164:45 [INFO] [stdout] | [INFO] [stdout] 164 | TypeConvCodeSubstParam::Tmp(&p[1..]) [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] | [INFO] [stdout] note: the prefix was tested here [INFO] [stdout] --> src/typemap.rs:163:28 [INFO] [stdout] | [INFO] [stdout] 163 | let param_id = if p.starts_with('$') { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip [INFO] [stdout] help: try using the `strip_prefix` method [INFO] [stdout] | [INFO] [stdout] 163 ~ let param_id = if let Some() = p.strip_prefix('$') { [INFO] [stdout] 164 ~ TypeConvCodeSubstParam::Tmp() [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap.rs:166:46 [INFO] [stdout] | [INFO] [stdout] 166 | TypeConvCodeSubstParam::Name(&p) [INFO] [stdout] | ^^ help: change this to: `p` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: direct implementation of `ToString` [INFO] [stdout] --> src/typemap.rs:184:1 [INFO] [stdout] | [INFO] [stdout] 184 | / impl ToString for TypeConvCode { [INFO] [stdout] 185 | | fn to_string(&self) -> String { [INFO] [stdout] 186 | | self.code.clone() [INFO] [stdout] 187 | | } [INFO] [stdout] 188 | | } [INFO] [stdout] | |_^ [INFO] [stdout] | [INFO] [stdout] = help: prefer implementing `Display` instead [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#to_string_trait_impl [INFO] [stdout] = note: `#[warn(clippy::to_string_trait_impl)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: using `contains()` instead of `iter().any()` is more efficient [INFO] [stdout] --> src/typemap.rs:349:16 [INFO] [stdout] | [INFO] [stdout] 349 | if graph_snapshot.new_edges.iter().any(|x| *x == *edge) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `graph_snapshot.new_edges.contains(edge)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref on an immutable reference [INFO] [stdout] --> src/typemap.rs:755:62 [INFO] [stdout] | [INFO] [stdout] 755 | ... .replace(&ty_param_name, &*rust_ty.normalized_name.as_str()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `rust_ty.normalized_name.as_str()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: deref which would be done by auto-deref [INFO] [stdout] --> src/typemap.rs:758:62 [INFO] [stdout] | [INFO] [stdout] 758 | ... .replace(&ty_param_name, &*class.name.to_string()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&class.name.to_string()` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take` [INFO] [stdout] --> src/typemap.rs:1024:9 [INFO] [stdout] | [INFO] [stdout] 1024 | mem::replace(&mut self.not_merged_data, vec![]) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut self.not_merged_data)` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap.rs:1155:59 [INFO] [stdout] | [INFO] [stdout] 1155 | let mut ty_graph = TypeGraphSnapshot::new(conv_graph, &rust_names_map); [INFO] [stdout] | ^^^^^^^^^^^^^^^ help: change this to: `rust_names_map` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/typemap.rs:1214:29 [INFO] [stdout] | [INFO] [stdout] 1214 | ... &ty_graph.conv_graph, [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ help: change this to: `ty_graph.conv_graph` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: large size difference between variants [INFO] [stdout] --> src/types.rs:93:1 [INFO] [stdout] | [INFO] [stdout] 93 | / pub(crate) enum FnArg { [INFO] [stdout] 94 | | SelfArg(Span, SelfTypeVariant), [INFO] [stdout] | | ------------------------------ the second-largest variant contains at least 13 bytes [INFO] [stdout] 95 | | Default(NamedArg), [INFO] [stdout] | | ----------------- the largest variant contains at least 392 bytes [INFO] [stdout] 96 | | } [INFO] [stdout] | |_^ the entire enum is at least 392 bytes [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stdout] help: consider boxing the large fields or introducing indirection in some other way to reduce the total size of the enum [INFO] [stdout] | [INFO] [stdout] 95 - Default(NamedArg), [INFO] [stdout] 95 + Default(Box), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this expression creates a reference which is immediately dereferenced by the compiler [INFO] [stdout] --> src/types.rs:173:34 [INFO] [stdout] | [INFO] [stdout] 173 | acc.push_str(&x); [INFO] [stdout] | ^^ help: change this to: `x` [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: doc list item overindented [INFO] [stdout] --> src/lib.rs:118:9 [INFO] [stdout] | [INFO] [stdout] 118 | /// for example android.support.annotation.NonNull [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using ` ` (2 spaces) [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_overindented_list_items [INFO] [stdout] = note: `#[warn(clippy::doc_overindented_list_items)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: doc list item overindented [INFO] [stdout] --> src/lib.rs:135:9 [INFO] [stdout] | [INFO] [stdout] 135 | /// for example for Android Studio [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using ` ` (2 spaces) [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_overindented_list_items [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: doc list item overindented [INFO] [stdout] --> src/lib.rs:136:9 [INFO] [stdout] | [INFO] [stdout] 136 | /// you should pass android.support.annotation [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using ` ` (2 spaces) [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_overindented_list_items [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this can be `std::io::Error::other(_)` [INFO] [stdout] --> src/lib.rs:640:22 [INFO] [stdout] | [INFO] [stdout] 640 | .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#io_other_error [INFO] [stdout] = note: `#[warn(clippy::io_other_error)]` on by default [INFO] [stdout] help: use `std::io::Error::other` [INFO] [stdout] | [INFO] [stdout] 640 - .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?; [INFO] [stdout] 640 + .map_err(|e| io::Error::other(format!("{}", e)))?; [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: this can be `std::io::Error::other(_)` [INFO] [stdout] --> src/lib.rs:672:24 [INFO] [stdout] | [INFO] [stdout] 672 | Some(2) => Err(io::Error::new( [INFO] [stdout] | ________________________^ [INFO] [stdout] 673 | | io::ErrorKind::Other, [INFO] [stdout] 674 | | "Rustfmt parsing errors.".to_string(), [INFO] [stdout] 675 | | )), [INFO] [stdout] | |_________^ [INFO] [stdout] | [INFO] [stdout] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#io_other_error [INFO] [stdout] help: use `std::io::Error::other` [INFO] [stdout] | [INFO] [stdout] 672 ~ Some(2) => Err(io::Error::other( [INFO] [stdout] 673 ~ "Rustfmt parsing errors.".to_string(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast.rs:721:41 [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec { [INFO] [stdout] | ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec<'_> { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast/subst_map.rs:33:28 [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem] { [INFO] [stdout] | ^^^^^ ^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | | | | [INFO] [stdout] | | | the same lifetime is hidden here [INFO] [stdout] | | the same lifetime is elided here [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem<'_>] { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/typemap_macro.rs:193:9 [INFO] [stdout] | [INFO] [stdout] 193 | &self, [INFO] [stdout] | ^^^^^ the lifetime is elided here [INFO] [stdout] ... [INFO] [stdout] 197 | ) -> Option [INFO] [stdout] | ^^^^^^^^^^^^^^^^ the same lifetime is hidden here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 197 | ) -> Option> [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 14.30s [INFO] running `Command { std: "docker" "inspect" "34c3619d455c577172f1ab3585c22f0c4f394d2a8ed0de779c6a5318347f17e6", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "34c3619d455c577172f1ab3585c22f0c4f394d2a8ed0de779c6a5318347f17e6", kill_on_drop: false }` [INFO] [stdout] 34c3619d455c577172f1ab3585c22f0c4f394d2a8ed0de779c6a5318347f17e6