in work

Author: waralexrom

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

@@ -1,4 +1,5 @@
 use super::{NeonObject, NeonTypeHandle};
+use super::primitive_root_holder::*;
 use crate::wrappers::neon::inner_types::NeonInnerTypes;
 use std::marker::PhantomData;
 

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

@@ -1,5 +1,6 @@
 use super::RootHolder;
 use crate::wrappers::neon::context::{ContextHolder, SafeCallFn};
+use crate::wrappers::object::NativeObject;
 use cubesql::CubeError;
 use neon::prelude::*;
 use std::rc::Rc;
@@ -21,3 +22,42 @@ impl<C: Context<'static> + 'static> NeonObject<C> {
         Self { root_holder: root }
     }
 }
+
+/* impl<C: Context<'static> + 'static> NativeObject<NeonInnerTypes<C>> for NeonObject<C> {
+    fn get_context(&self) -> ContextHolder<C> {
+        self.root_holder.ge.clone()
+    }
+
+    fn into_struct(self) -> Result<NeonStruct<C>, CubeError> {
+        let obj = self.downcast_with_err_msg::<JsObject>("NeonObject is not the JsObject")?;
+        Ok(NeonStruct::new(obj))
+    }
+    fn into_function(self) -> Result<NeonFunction<C>, CubeError> {
+        let obj = self.downcast_with_err_msg::<JsFunction>("NeonObject is not the JsArray")?;
+        Ok(NeonFunction::new(obj))
+    }
+    fn into_array(self) -> Result<NeonArray<C>, CubeError> {
+        let obj = self.downcast_with_err_msg::<JsArray>("NeonObject is not the JsArray")?;
+        Ok(NeonArray::new(obj))
+    }
+    fn into_string(self) -> Result<NeonString<C>, CubeError> {
+        let obj = self.downcast_with_err_msg::<JsString>("NeonObject is not the JsString")?;
+        Ok(NeonString::new(obj))
+    }
+    fn into_number(self) -> Result<NeonNumber<C>, CubeError> {
+        let obj = self.downcast_with_err_msg::<JsNumber>("NeonObject is not the JsNumber")?;
+        Ok(NeonNumber::new(obj))
+    }
+    fn into_boolean(self) -> Result<NeonBoolean<C>, CubeError> {
+        let obj = self.downcast_with_err_msg::<JsBoolean>("NeonObject is not the JsBoolean")?;
+        Ok(NeonBoolean::new(obj))
+    }
+
+    fn is_null(&self) -> Result<bool, CubeError> {
+        self.is_a::<JsNull>()
+    }
+
+    fn is_undefined(&self) -> Result<bool, CubeError> {
+        self.is_a::<JsUndefined>()
+    }
+} */

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

@@ -18,7 +18,7 @@ impl<C: Context<'static> + 'static, V: Object + 'static> ObjectNeonTypeHolder<C,
         })
     }
 
-    fn get_context(&self) -> ContextHolder<C> {
+    pub fn get_context(&self) -> ContextHolder<C> {
         self.context.clone()
     }
 

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

@@ -121,7 +121,7 @@ impl<C: Context<'static> + 'static, V: Value + NeonPrimitiveMapping + 'static>
         Ok(Self { context, value })
     }
 
-    fn get_context(&self) -> ContextHolder<C> {
+    pub fn get_context(&self) -> ContextHolder<C> {
         self.context.clone()
     }
 

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

@@ -95,6 +95,19 @@ impl<C: Context<'static> + 'static> RootHolder<C> {
         T::upcast(typed_holder)
     }
 
+    pub fn get_context(&self) -> ContextHolder<C> {
+        match self {
+            Self::Null(v) => v.get_context(),
+            Self::Undefined(v) => v.get_context(),
+            Self::Boolean(v) => v.get_context(),
+            Self::Number(v) => v.get_context(),
+            Self::String(v) => v.get_context(),
+            Self::Array(v) => v.get_context(),
+            Self::Function(v) => v.get_context(),
+            Self::Struct(v) => v.get_context(),
+        }
+    }
+
     define_into_method!(into_null, Null, PrimitiveNeonTypeHolder<C, JsNull>, "Object is not the Null object");
     define_into_method!(into_undefined, Undefined, PrimitiveNeonTypeHolder<C, JsUndefined>, "Object is not the Undefined object");
     define_into_method!(into_boolean, Boolean, PrimitiveNeonTypeHolder<C, JsBoolean>, "Object is not the Boolean object");