in work

Author: waralexrom

rust/cubenativeutils/src/wrappers/context.rs

@@ -1,4 +1,5 @@
 use super::inner_types::InnerTypes;
+use super::object::NativeBox;
 use super::object_handle::NativeObjectHandle;
 
 pub trait NativeContext<IT: InnerTypes>: Clone {
@@ -8,6 +9,7 @@ pub trait NativeContext<IT: InnerTypes>: Clone {
     fn undefined(&self) -> NativeObjectHandle<IT>;
     fn empty_array(&self) -> IT::Array;
     fn empty_struct(&self) -> IT::Struct;
+    //fn boxed<T: 'static>(&self, value: T) -> impl NativeBox<IT, T>;
     fn to_string_fn(&self, result: String) -> IT::Function;
 }
 

rust/cubenativeutils/src/wrappers/neon/context.rs

@@ -61,10 +61,6 @@ impl<'cx, C: Context<'cx> + 'cx> ContextHolder<'cx, C> {
         context.with_context(f)
     }
 
-    /* pub fn as_native_context_holder(&self) -> NativeContextHolder {
-        NativeContextHolder::new(Box::new(self.clone()))
-    } */
-
     pub fn weak(&self) -> WeakContextHolder<'cx, C> {
         WeakContextHolder {
             context: Rc::downgrade(&self.context),

rust/cubenativeutils/src/wrappers/neon/object/base_types.rs

@@ -1,75 +1,107 @@
-use super::NeonObject;
+use super::{NeonObject, NeonTypeHandle};
 use crate::wrappers::neon::inner_types::NeonInnerTypes;
+use std::marker::PhantomData;
 
-use crate::wrappers::object::{NativeBoolean, NativeNumber, NativeString, NativeType};
+use crate::wrappers::object::{NativeBoolean, NativeBox, NativeNumber, NativeString, NativeType};
 use cubesql::CubeError;
 use neon::prelude::*;
+use std::ops::Deref;
 
 pub struct NeonString<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsString>,
 }
 
 impl<'cx, C: Context<'cx>> NeonString<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsString>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonString<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeString<NeonInnerTypes<'cx, C>> for NeonString<'cx, C> {
     fn value(&self) -> Result<String, CubeError> {
         self.object
-            .map_downcast_neon_object::<JsString, _, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
     }
 }
 
 pub struct NeonNumber<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsNumber>,
 }
 
 impl<'cx, C: Context<'cx>> NeonNumber<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsNumber>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonNumber<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeNumber<NeonInnerTypes<'cx, C>> for NeonNumber<'cx, C> {
     fn value(&self) -> Result<f64, CubeError> {
         self.object
-            .map_downcast_neon_object::<JsNumber, _, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
     }
 }
 
 pub struct NeonBoolean<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsBoolean>,
 }
 
 impl<'cx, C: Context<'cx>> NeonBoolean<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsBoolean>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonBoolean<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeBoolean<NeonInnerTypes<'cx, C>> for NeonBoolean<'cx, C> {
     fn value(&self) -> Result<bool, CubeError> {
         self.object
-            .map_downcast_neon_object::<JsBoolean, _, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
+    }
+}
+
+pub struct NeonBox<'cx: 'static, C: Context<'cx>, T: 'static> {
+    object: NeonTypeHandle<'cx, C, JsBox<T>>,
+    _marker: PhantomData<T>,
+}
+
+impl<'cx: 'static, C: Context<'cx>, T: 'static> NeonBox<'cx, C, T> {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsBox<T>>) -> Self {
+        Self {
+            object,
+            _marker: PhantomData::default(),
+        }
+    }
+}
+
+impl<'cx: 'static, C: Context<'cx> + 'cx, T: 'static> NativeType<NeonInnerTypes<'cx, C>>
+    for NeonBox<'cx, C, T>
+{
+    fn into_object(self) -> NeonObject<'cx, C> {
+        self.object.upcast()
+    }
+}
+
+impl<'cx: 'static, C: Context<'cx> + 'cx, T: 'static> NativeBox<NeonInnerTypes<'cx, C>, T>
+    for NeonBox<'cx, C, T>
+{
+    fn deref_value(&self) -> &T {
+        self.object.get_object_ref().deref()
     }
 }

rust/cubenativeutils/src/wrappers/neon/object/mod.rs

@@ -13,34 +13,43 @@ use crate::wrappers::object::NativeObject;
 use cubesql::CubeError;
 use neon::prelude::*;
 
-pub struct NeonObject<'cx: 'static, C: Context<'cx>> {
+pub struct NeonTypeHandle<'cx, C: Context<'cx>, V: Value + 'cx> {
     context: ContextHolder<'cx, C>,
-    object: Handle<'cx, JsValue>,
+    object: Handle<'cx, V>,
 }
 
-impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
-    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, JsValue>) -> Self {
+impl<'cx: 'static, C: Context<'cx> + 'cx, V: Value + 'cx> NeonTypeHandle<'cx, C, V> {
+    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, V>) -> Self {
         Self { context, object }
     }
 
-    pub fn get_object(&self) -> Handle<'cx, JsValue> {
+    fn get_context(&self) -> ContextHolder<'cx, C> {
+        self.context.clone()
+    }
+
+    pub fn get_object(&self) -> Handle<'cx, V> {
         self.object.clone()
     }
 
-    pub fn get_object_ref(&self) -> &Handle<'cx, JsValue> {
+    pub fn get_object_ref(&self) -> &Handle<'cx, V> {
         &self.object
     }
 
-    pub fn into_object(self) -> Handle<'cx, JsValue> {
+    pub fn into_object(self) -> Handle<'cx, V> {
         self.object
     }
 
+    pub fn upcast(&self) -> NeonObject<'cx, C> {
+        NeonObject::new(self.context.clone(), self.object.upcast())
+    }
+
     pub fn map_neon_object<T, F>(&self, f: F) -> T
     where
-        F: FnOnce(&mut C, &Handle<'cx, JsValue>) -> T,
+        F: FnOnce(&mut C, &Handle<'cx, V>) -> T,
     {
         self.context.with_context(|cx| f(cx, &self.object))
     }
+
     pub fn map_downcast_neon_object<JT: Value, T, F>(&self, f: F) -> Result<T, CubeError>
     where
         F: FnOnce(&mut C, &Handle<'cx, JT>) -> Result<T, CubeError>,
@@ -59,6 +68,63 @@ impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
     }
 }
 
+impl<'cx: 'static, C: Context<'cx>, V: Value + 'cx> Clone for NeonTypeHandle<'cx, C, V> {
+    fn clone(&self) -> Self {
+        Self {
+            context: self.context.clone(),
+            object: self.object.clone(),
+        }
+    }
+}
+
+pub struct NeonObject<'cx: 'static, C: Context<'cx>> {
+    context: ContextHolder<'cx, C>,
+    object: Handle<'cx, JsValue>,
+}
+
+impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
+    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, JsValue>) -> Self {
+        Self { context, object }
+    }
+
+    pub fn get_object(&self) -> Handle<'cx, JsValue> {
+        self.object.clone()
+    }
+
+    pub fn get_object_ref(&self) -> &Handle<'cx, JsValue> {
+        &self.object
+    }
+
+    pub fn into_object(self) -> Handle<'cx, JsValue> {
+        self.object
+    }
+
+    pub fn is_a<U: Value>(&self) -> bool {
+        self.context.with_context(|cx| self.object.is_a::<U, _>(cx))
+    }
+
+    pub fn downcast<U: Value>(&self) -> Result<NeonTypeHandle<'cx, C, U>, CubeError> {
+        let obj = self.context.with_context(|cx| {
+            self.object
+                .downcast::<U, _>(cx)
+                .map_err(|_| CubeError::internal("Downcast error".to_string()))
+        })?;
+        Ok(NeonTypeHandle::new(self.context.clone(), obj))
+    }
+
+    pub fn downcast_with_err_msg<U: Value>(
+        &self,
+        msg: &str,
+    ) -> Result<NeonTypeHandle<'cx, C, U>, CubeError> {
+        let obj = self.context.with_context(|cx| {
+            self.object
+                .downcast::<U, _>(cx)
+                .map_err(|_| CubeError::internal(msg.to_string()))
+        })?;
+        Ok(NeonTypeHandle::new(self.context.clone(), obj))
+    }
+}
+
 impl<'cx: 'static, C: Context<'cx> + 'cx> NativeObject<NeonInnerTypes<'cx, C>>
     for NeonObject<'cx, C>
 {
@@ -67,52 +133,28 @@ impl<'cx: 'static, C: Context<'cx> + 'cx> NativeObject<NeonInnerTypes<'cx, C>>
     }
 
     fn into_struct(self) -> Result<NeonStruct<'cx, C>, CubeError> {
-        if !self.is_a::<JsObject>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsObject"
-            )));
-        }
-        Ok(NeonStruct::new(self))
+        let obj = self.downcast_with_err_msg::<JsObject>("NeonObject is not the JsObject")?;
+        Ok(NeonStruct::new(obj))
     }
     fn into_function(self) -> Result<NeonFunction<'cx, C>, CubeError> {
-        if !self.is_a::<JsFunction>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsFunction"
-            )));
-        }
-        Ok(NeonFunction::new(self))
+        let obj = self.downcast_with_err_msg::<JsFunction>("NeonObject is not the JsArray")?;
+        Ok(NeonFunction::new(obj))
     }
     fn into_array(self) -> Result<NeonArray<'cx, C>, CubeError> {
-        if !self.is_a::<JsArray>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsArray"
-            )));
-        }
-        Ok(NeonArray::new(self))
+        let obj = self.downcast_with_err_msg::<JsArray>("NeonObject is not the JsArray")?;
+        Ok(NeonArray::new(obj))
     }
     fn into_string(self) -> Result<NeonString<'cx, C>, CubeError> {
-        if !self.is_a::<JsString>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsString"
-            )));
-        }
-        Ok(NeonString::new(self))
+        let obj = self.downcast_with_err_msg::<JsString>("NeonObject is not the JsString")?;
+        Ok(NeonString::new(obj))
     }
     fn into_number(self) -> Result<NeonNumber<'cx, C>, CubeError> {
-        if !self.is_a::<JsNumber>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsNumber"
-            )));
-        }
-        Ok(NeonNumber::new(self))
+        let obj = self.downcast_with_err_msg::<JsNumber>("NeonObject is not the JsNumber")?;
+        Ok(NeonNumber::new(obj))
     }
     fn into_boolean(self) -> Result<NeonBoolean<'cx, C>, CubeError> {
-        if !self.is_a::<JsBoolean>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsBoolean"
-            )));
-        }
-        Ok(NeonBoolean::<C>::new(self))
+        let obj = self.downcast_with_err_msg::<JsBoolean>("NeonObject is not the JsBoolean")?;
+        Ok(NeonBoolean::new(obj))
     }
 
     fn is_null(&self) -> bool {