Implement borrow stack for node graph

node-graph/gstd/Cargo.toml

@@ -17,6 +17,7 @@ default = ["derive", "memoization"]
 
 [dependencies]
 graphene-core = {path = "../gcore"}
+borrow_stack = {path = "../borrow_stack"}
 dyn-any = {path = "../dyn-any", features = ["derive"]}
 graph-proc-macros = {path = "../proc-macro", optional = true}
 once_cell = {version= "1.10", optional = true}

node-graph/gstd/src/lib.rs

@@ -9,7 +9,6 @@ pub mod memo;
 pub use graphene_core::*;
 
 use dyn_any::{downcast_ref, DynAny, StaticType};
-use std::any::Any;
 pub type DynNode<'n, T> = &'n (dyn Node<'n, (), Output = T> + 'n);
 pub type DynAnyNode<'n> = &'n (dyn Node<'n, (), Output = &'n dyn DynAny<'n>> + 'n);
 
@@ -18,11 +17,11 @@ pub trait DynamicInput<'n> {
     fn set_arg_by_index(&mut self, index: usize, value: DynAnyNode<'n>);
 }
 
-pub trait AnyRef<'n, I: StaticType<'n>>: Node<'n, I> {
+pub trait AnyRef<'n, I: StaticType>: Node<'n, I> {
     fn any(&'n self, input: &'n dyn DynAny<'n>) -> Self::Output;
 }
 
-impl<'n, T: Node<'n, I>, I: StaticType<'n>> AnyRef<'n, I> for T {
+impl<'n, T: Node<'n, I>, I: StaticType + 'n> AnyRef<'n, I> for T {
     fn any(&'n self, input: &'n dyn DynAny<'n>) -> Self::Output {
         self.eval(downcast_ref::<I>(input).unwrap_or_else(|| {
             panic!(

node-graph/gstd/src/main.rs

@@ -1,6 +1,7 @@
+use borrow_stack::BorrowStack;
 //#![feature(generic_associated_types)]
-use dyn_any::StaticType;
-use graphene_std::value::{AnyRefNode, ValueNode};
+use dyn_any::{DynAny, StaticType};
+use graphene_std::value::{AnyRefNode, AnyValueNode, StorageNode, ValueNode};
 use graphene_std::*;
 
 /*fn mul(#[dyn_any(default)] a: f32, b: f32) -> f32 {
@@ -70,9 +71,39 @@ mod mul {
         }
     }
 }
+type SNode<'n> = dyn Node<'n, (), Output = &'n dyn DynAny<'n>>;
+
+struct NodeStore<'n>(borrow_stack::FixedSizeStack<'n, Box<SNode<'n>>>);
+
+impl<'n> NodeStore<'n> {
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn push(&'n mut self, f: fn(&'n [Box<SNode>]) -> Box<SNode<'n>>) {
+        unsafe { self.0.push(f(self.0.get())) };
+    }
+
+    /*fn get_index(&'n self, index: usize) -> &'n SNode<'n> {
+        assert!(index < self.0.len());
+        &unsafe { self.0.get()[index] }
+    }*/
+}
 
 fn main() {
     //let mut mul = mul::MulNode::new();
+    let mut stack: borrow_stack::FixedSizeStack<Box<dyn Node<'_, (), Output = &dyn DynAny>>> =
+        borrow_stack::FixedSizeStack::new(42);
+    unsafe { stack.push(Box::new(AnyValueNode::new(1f32))) };
+    //let node = unsafe { stack.get(0) };
+    //let boxed = Box::new(StorageNode::new(node));
+    //unsafe { stack.push(boxed) };
+    let result = unsafe { &stack.get()[0] }.eval(&());
+    /*unsafe {
+        stack
+            .push(Box::new(AnyRefNode::new(stack.get(0).as_ref()))
+                as Box<dyn Node<(), Output = &dyn DynAny>>)
+    };*/
     let f = (3.2f32, 3.1f32);
     let a = ValueNode::new(1.);
     let id = std::any::TypeId::of::<&f32>();

node-graph/gstd/src/memo.rs

@@ -30,6 +30,7 @@ impl<'n, CachedNode: Node<'n, Input>, Input> Cache for CacheNode<'n, CachedNode,
     }
 }
 
-use dyn_any::{DynAny, StaticType};
+/*use dyn_any::{DynAny, StaticType};
 #[derive(DynAny)]
 struct Boo<'a>(&'a u8);
+*/

node-graph/gstd/src/value.rs

@@ -2,21 +2,55 @@ use core::marker::PhantomData;
 pub use graphene_core::value::*;
 use graphene_core::Node;
 
-use dyn_any::{DynAny, StaticType};
-pub struct AnyRefNode<'n, N: Node<'n, I, Output = &'n O>, I, O>(
+use dyn_any::{DynAny, StaticType, StaticTypeSized};
+
+pub struct AnyRefNode<'n, N: Node<'n, I, Output = O>, I, O>(
     &'n N,
     PhantomData<&'n I>,
     PhantomData<&'n O>,
 );
-impl<'n, N: Node<'n, I, Output = &'n O>, I, O: DynAny<'n>> Node<'n, I> for AnyRefNode<'n, N, I, O> {
+
+impl<'n, N: Node<'n, I, Output = &'n O>, I, O: DynAny<'n>> Node<'n, I>
+    for AnyRefNode<'n, N, I, &'n O>
+{
     type Output = &'n (dyn DynAny<'n>);
     fn eval(&'n self, input: &'n I) -> Self::Output {
         let value: &O = self.0.eval(input);
         value
     }
 }
-impl<'n, N: Node<'n, I, Output = &'n O>, I, O: 'static> AnyRefNode<'n, N, I, O> {
-    pub fn new(n: &'n N) -> AnyRefNode<'n, N, I, O> {
+impl<'n, N: Node<'n, I, Output = &'n O>, I, O: 'n + ?Sized> AnyRefNode<'n, N, I, &'n O> {
+    pub fn new(n: &'n N) -> AnyRefNode<'n, N, I, &'n O> {
         AnyRefNode(n, PhantomData, PhantomData)
     }
 }
+
+pub struct StorageNode<'n>(&'n dyn Node<'n, (), Output = &'n dyn DynAny<'n>>);
+
+impl<'n> Node<'n, ()> for StorageNode<'n> {
+    type Output = &'n (dyn DynAny<'n>);
+    fn eval(&'n self, input: &'n ()) -> Self::Output {
+        let value = self.0.eval(input);
+        value
+    }
+}
+impl<'n> StorageNode<'n> {
+    pub fn new<N: Node<'n, (), Output = &'n dyn DynAny<'n>>>(n: &'n N) -> StorageNode<'n> {
+        StorageNode(n)
+    }
+}
+
+#[derive(Default)]
+pub struct AnyValueNode<'n, T>(T, PhantomData<&'n ()>);
+impl<'n, T: 'n + DynAny<'n>> Node<'n, ()> for AnyValueNode<'n, T> {
+    type Output = &'n dyn DynAny<'n>;
+    fn eval(&'n self, _input: &()) -> &'n dyn DynAny<'n> {
+        &self.0
+    }
+}
+
+impl<'n, T> AnyValueNode<'n, T> {
+    pub const fn new(value: T) -> AnyValueNode<'n, T> {
+        AnyValueNode(value, PhantomData)
+    }
+}