Rename wrappers to managed data

Taaitaaiger · Apr 21, 2023 · 189629a · 189629a
1 parent 5fb65dc
commit 189629a
Show file tree

Hide file tree

Showing 132 changed files with 1,971 additions and 2,221 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,9 @@
+#### v0.18
+ - jlrs is compatible with Julia 1.7 again, but this version not actively tested or supported. Version features have been added to select a particular version of Julia.
+
+ - Foreign types can be reinitialized with `reinit_foreign_type`, this is only available when Julia 1.10 (the current nightly version) is used.
+
+
 #### v0.17
  - Atomic struct fields are now atomic in the generated bindings.
 

diff --git a/examples/async_tasks.rs b/examples/async_tasks.rs
@@ -47,9 +47,9 @@ impl AsyncTask for MyTask {
         unsafe {
             Module::main(&frame)
                 .submodule(&frame, "MyModule")?
-                .wrapper()
+                .as_managed()
                 .function(&frame, "complexfunc")?
-                .wrapper()
+                .as_managed()
                 .call_async(&mut frame, &mut [dims, iters])
                 .await
                 .into_jlrs_result()?

diff --git a/examples/call_julia.rs b/examples/call_julia.rs
@@ -34,11 +34,11 @@ fn main() {
                 Module::main(&frame)
                     // the submodule doesn't have to be rooted because it's never reloaded.
                     .submodule(&frame, "MyModule")?
-                    .wrapper()
+                    .as_managed()
                     // the same holds true for the function: the module is never reloaded so it's
                     // globally rooted
                     .function(&frame, "complexfunc")?
-                    .wrapper()
+                    .as_managed()
                     // Call the function with the two arguments it takes
                     .call2(&mut frame, dim, iters)
                     // If you don't want to use the exception, it can be converted to a `JlrsError`

diff --git a/examples/ccall_throw_exception.rs b/examples/ccall_throw_exception.rs
@@ -16,7 +16,7 @@ pub unsafe extern "C" fn assert_less_than(a: i32, b: i32) {
             Module::core(&frame)
                 .global(&frame, "AssertionError")
                 .expect("AssertionError does not exist in Core")
-                .value()
+                .as_value()
                 .cast::<DataType>()
                 .expect("AssertionError is not a DataType")
                 .instantiate_unchecked(frame.as_mut(), [msg])

diff --git a/examples/fully_async_async_std.rs b/examples/fully_async_async_std.rs
@@ -47,9 +47,9 @@ impl AsyncTask for MyTask {
         unsafe {
             Module::main(&frame)
                 .submodule(&frame, "MyModule")?
-                .wrapper()
+                .as_managed()
                 .function(&frame, "complexfunc")?
-                .wrapper()
+                .as_managed()
                 .call_async(&mut frame, &mut [dims, iters])
                 .await
                 .into_jlrs_result()?

diff --git a/examples/fully_async_tokio.rs b/examples/fully_async_tokio.rs
@@ -47,9 +47,9 @@ impl AsyncTask for MyTask {
         unsafe {
             Module::main(&frame)
                 .submodule(&frame, "MyModule")?
-                .wrapper()
+                .as_managed()
                 .function(&frame, "complexfunc")?
-                .wrapper()
+                .as_managed()
                 .call_async(&mut frame, &mut [dims, iters])
                 .await
                 .into_jlrs_result()?

diff --git a/examples/nested_async_scopes.rs b/examples/nested_async_scopes.rs
@@ -52,9 +52,9 @@ impl AsyncTask for MyTask {
                 let out = unsafe {
                     Module::main(&frame)
                         .submodule(&frame, "MyModule")?
-                        .wrapper()
+                        .as_managed()
                         .function(&frame, "complexfunc")?
-                        .wrapper()
+                        .as_managed()
                         .call_async(&mut frame, &mut [dims, iters])
                         .await
                         .into_jlrs_result()?

diff --git a/examples/persistent_tasks.rs b/examples/persistent_tasks.rs
@@ -52,7 +52,9 @@ impl PersistentTask for AccumulatorTask {
                 .scope(|mut frame| {
                     // A nested scope is used to only root a single value in the frame provided to
                     // init, rather than two.
-                    let func = Module::main(&frame).global(&frame, "MutFloat64")?.value();
+                    let func = Module::main(&frame)
+                        .global(&frame, "MutFloat64")?
+                        .as_value();
                     let init_v = Value::new(&mut frame, self.init_value);
 
                     Ok(func.call1(output, init_v))

diff --git a/examples/plot.rs b/examples/plot.rs
@@ -30,7 +30,7 @@ impl PersistentTask for MyTask {
     ) -> JlrsResult<Self::State<'frame>> {
         unsafe {
             // Create the first plot with no data, but with a custom label for the y-axis.
-            let plot_fn = Module::plots(&frame).function(&frame, "plot")?.wrapper();
+            let plot_fn = Module::plots(&frame).function(&frame, "plot")?.as_managed();
 
             let ylabel_str = JuliaString::new(&mut frame, &self.ylabel);
             let ylabel =
@@ -55,11 +55,11 @@ impl PersistentTask for MyTask {
             let n = Value::new(&mut frame, 100usize);
             let data = Module::base(&frame)
                 .function(&frame, "randn")?
-                .wrapper()
+                .as_managed()
                 .call1(&mut frame, n)
                 .into_jlrs_result()?;
 
-            let plot_fn = Module::plots(&frame).function(&frame, "plot")?.wrapper();
+            let plot_fn = Module::plots(&frame).function(&frame, "plot")?.as_managed();
 
             state
                 .0

diff --git a/jlrs/src/async_util/future.rs b/jlrs/src/async_util/future.rs
@@ -15,16 +15,16 @@ use smallvec::SmallVec;
 
 use crate::{
     call::{Call, ProvideKeywords, WithKeywords},
-    error::{JuliaResult, CANNOT_DISPLAY_VALUE},
-    memory::target::{frame::AsyncGcFrame, unrooted::Unrooted},
-    private::Private,
-    wrappers::ptr::{
+    data::managed::{
         module::Module,
-        private::WrapperPriv,
+        private::ManagedPriv,
         task::Task,
         value::{Value, MAX_SIZE},
-        Wrapper,
+        Managed,
     },
+    error::{JuliaResult, CANNOT_DISPLAY_VALUE},
+    memory::target::{frame::AsyncGcFrame, unrooted::Unrooted},
+    private::Private,
 };
 
 pub(crate) struct TaskState<'frame, 'data> {
@@ -66,10 +66,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "asynccall")
                 .expect("asynccall not available")
-                .wrapper()
+                .as_managed()
                 .call(&mut *frame, &mut vals)
                 .unwrap_or_else(|e| {
                     let msg = e.display_string_or(CANNOT_DISPLAY_VALUE);
@@ -121,10 +121,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "interactivecall")
                 .expect("interactivecall not available")
-                .wrapper()
+                .as_managed()
                 .call(&mut *frame, &mut vals)
                 .unwrap_or_else(|e| {
                     let msg = e.display_string_or(CANNOT_DISPLAY_VALUE);
@@ -175,10 +175,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "scheduleasynclocal")
                 .expect("scheduleasynclocal not available")
-                .wrapper()
+                .as_managed()
                 .call(&mut *frame, &mut vals)
                 .unwrap_or_else(|e| {
                     let msg = e.display_string_or(CANNOT_DISPLAY_VALUE);
@@ -229,10 +229,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "scheduleasync")
                 .expect("scheduleasync not available")
-                .wrapper()
+                .as_managed()
                 .call(&mut *frame, &mut vals)
                 .unwrap_or_else(|e| {
                     let msg = e.display_string_or(CANNOT_DISPLAY_VALUE);
@@ -273,10 +273,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "postblocking")
                 .expect("postblocking not available")
-                .wrapper()
+                .as_managed()
                 .call3(&mut *frame, fn_ptr, task_ptr, state_ptr_boxed)
                 .unwrap_or_else(|e| {
                     let msg = e.display_string_or(CANNOT_DISPLAY_VALUE);
@@ -326,10 +326,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "asynccall")
                 .expect("asynccall not available")
-                .wrapper()
+                .as_managed()
                 .provide_keywords(func.keywords())
                 .expect("Keywords invalid")
                 .call(&mut *frame, &mut vals)
@@ -382,10 +382,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "interactivecall")
                 .expect("interactivecall not available")
-                .wrapper()
+                .as_managed()
                 .provide_keywords(func.keywords())
                 .expect("Keywords invalid")
                 .call(&mut *frame, &mut vals)
@@ -438,10 +438,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             let task = Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "scheduleasynclocal")
                 .expect("scheduleasynclocal not available")
-                .wrapper()
+                .as_managed()
                 .provide_keywords(func.keywords())
                 .expect("Keywords invalid")
                 .call(&mut *frame, &mut vals)
@@ -494,10 +494,10 @@ impl<'frame, 'data> JuliaFuture<'frame, 'data> {
             Module::main(&frame)
                 .submodule(&frame, "JlrsMultitask")
                 .expect("JlrsMultitask not available")
-                .wrapper()
+                .as_managed()
                 .function(&frame, "scheduleasync")
                 .expect("scheduleasync not available")
-                .wrapper()
+                .as_managed()
                 .provide_keywords(func.keywords())
                 .expect("Keywords invalid")
                 .call(&mut *frame, &mut vals)
@@ -533,7 +533,7 @@ impl<'frame, 'data> Future for JuliaFuture<'frame, 'data> {
                     let f = Module::base(&global)
                         .function(&global, "fetch")
                         .unwrap()
-                        .wrapper();
+                        .as_managed();
 
                     let res = jl_call1(f.unwrap(Private), task.unwrap(Private).cast());
                     let exc = jl_exception_occurred();

diff --git a/jlrs/src/async_util/internal.rs b/jlrs/src/async_util/internal.rs
@@ -10,14 +10,14 @@ use crate::{
         task::AsyncTask,
     },
     call::Call,
+    data::managed::{module::Module, string::JuliaString, value::Value, Managed},
     error::{JlrsError, JlrsResult},
     memory::{
         context::stack::Stack,
         stack_frame::StackFrame,
         target::frame::{AsyncGcFrame, GcFrame},
     },
     runtime::async_rt::{PersistentHandle, PersistentMessage},
-    wrappers::ptr::{module::Module, string::JuliaString, value::Value, Wrapper},
 };
 
 pub(crate) type InnerPersistentMessage<P> = Box<
@@ -468,9 +468,11 @@ where
                 let path = JuliaString::new(&mut frame, path);
                 Module::main(&frame)
                     .function(&frame, "include")?
-                    .wrapper()
+                    .as_managed()
                     .call1(&frame, path.as_value())
-                    .map_err(|e| JlrsError::exception(format!("Include error: {:?}", e.value())))?;
+                    .map_err(|e| {
+                        JlrsError::exception(format!("Include error: {:?}", e.as_value()))
+                    })?;
             }
             None => {}
         }
@@ -534,9 +536,9 @@ where
 
         Module::main(&unrooted)
             .submodule(&unrooted, "Jlrs")?
-            .wrapper()
+            .as_managed()
             .global(&unrooted, "color")?
-            .value()
+            .as_value()
             .set_nth_field_unchecked(0, enable);
 
         Ok(())

diff --git a/jlrs/src/async_util/task.rs b/jlrs/src/async_util/task.rs
@@ -25,9 +25,9 @@ use crate::{
 };
 use crate::{
     call::Call,
+    data::managed::{module::Module, value::Value},
     error::JlrsResult,
     memory::target::{frame::AsyncGcFrame, Target},
-    wrappers::ptr::{module::Module, value::Value},
 };
 
 /// A task that returns once.
@@ -374,12 +374,12 @@ pub fn sleep<'scope, 'data, T: Target<'scope>>(target: &T, duration: Duration) {
 
         // Is rooted when sleep is called.
         let secs = duration.as_millis() as usize as f64 / 1000.;
-        let secs = Value::new(target, secs).value();
+        let secs = Value::new(target, secs).as_value();
 
         Module::base(target)
             .global(target, "sleep")
             .expect("sleep not found")
-            .value()
+            .as_value()
             .call1(target, secs)
             .expect("sleep threw an exception");
     }