Parsing models implemented

assets/scenes/00.scene

@@ -1 +1,2 @@
-00/a.entity
+00/camera.entity
+00/van.entity

assets/scenes/00/a.entity

@@ -1 +0,0 @@
-name "Hello world"

assets/scenes/00/camera.entity

@@ -0,0 +1,2 @@
+camera
+transform translation 2.0 2.0 2.0 ...

assets/scenes/00/light.entity

@@ -0,0 +1,3 @@
+; spatial3d
+; transform ...
+; pointLight color #ffffff intensity 800

assets/scenes/00/van.entity

@@ -0,0 +1,3 @@
+transform ...
+visible
+model "models/van.glb" "Scene"

shell.nix

@@ -22,6 +22,7 @@ mkShell rec {
     vulkan-loader # Rendering
     xorg.libX11 xorg.libXcursor xorg.libXi xorg.libXrandr # To use the x11 feature
     tmux          # Sharing environemnt between editor and terminal
+    git-bug
   ];
   LD_LIBRARY_PATH = lib.makeLibraryPath buildInputs;
 

src/main.rs

@@ -32,7 +32,13 @@ fn main() {
         // .add_plugins(menu::MenuPlugin)
         // .add_plugins(window::WindowPlugin)
         .add_plugins(save::SavePlugin {
-            fns: vec![parse_save_name],
+            fns: vec![
+                parse_save_name,
+                parse_save_camera,
+                parse_save_visibility,
+                parse_save_transform,
+                parse_save_model,
+            ],
         })
         .run();
 }

src/parser.rs

@@ -1,3 +1,15 @@
+use bevy::{
+    core_pipeline::{
+        core_3d::graph::Core3d,
+        tonemapping::{DebandDither, Tonemapping},
+    },
+    render::{
+        camera::{CameraMainTextureUsages, CameraRenderGraph, Exposure},
+        primitives::Frustum,
+        view::{ColorGrading, VisibleEntities},
+    },
+};
+
 use crate::prelude::*;
 
 #[derive(Error, Debug)]
@@ -21,6 +33,8 @@ pub(crate) enum Token {
     Tag(String),
     Str(String),
     Num(f32),
+    Comment(String),
+    Etc,
 }
 
 ///
@@ -30,22 +44,35 @@ pub(crate) fn tokenize(line: &str) -> Vec<Token> {
     let mut l = line;
     let mut tokens = Vec::new();
 
+    // Check for comment
+    if let Ok((_, (_start, content))) = tuple((char::<&str, ()>(';'), not_line_ending))(line) {
+        tokens.push(Token::Comment(content.strip_prefix(" ").unwrap().into()));
+    } else {
+        // Check for all other token types in a loop
         while l.len() > 0 {
-        debug!("Line: {:?}", l);
+            if let Ok((rem, (_, _, s, _, _))) = tuple((
-        if let Ok((rem, (_, s, _))) = tuple((
+                space0,
                 char::<&str, ()>('"'),
                 take_until("\""),
                 char::<&str, ()>('"'),
+                space0,
             ))(l)
             {
                 debug!("Parsed string {:?}", s);
                 tokens.push(Token::Str(s.into()));
                 l = rem;
-        } else if let Ok((rem, num)) = float::<&str, ()>(l) {
+            } else if let Ok((rem, (_, num, _))) = tuple((space0, float::<&str, ()>, space0))(l) {
                 debug!("Parsed float {:?}", num);
                 tokens.push(Token::Num(num.into()));
                 l = rem;
-        } else if let Ok((rem, (_, tag, _))) = tuple((space0, alphanumeric1::<&str, ()>, space0))(l)
+            } else if let Ok((rem, (_, etc, _))) =
+                tuple((space0, tag::<&str, &str, ()>("..."), space0))(l)
+            {
+                debug!("Parsed etc. {:?}", etc);
+                tokens.push(Token::Etc);
+                l = rem;
+            } else if let Ok((rem, (_, tag, _))) =
+                tuple((space0, alphanumeric1::<&str, ()>, space0))(l)
             {
                 debug!("Parsed tag {:?}", tag);
                 tokens.push(Token::Tag(tag.into()));
@@ -55,6 +82,8 @@ pub(crate) fn tokenize(line: &str) -> Vec<Token> {
                 break;
             }
         }
+    }
+    debug!("Parsed tokens: {:?}", tokens);
 
     tokens
 }
@@ -80,34 +109,156 @@ fn test_tokenize() {
 ///
 /// Returns reflected `Transform`
 ///
+/// A fairly complicated parse function because Transform is sort of 3 components in one
+/// (translation, rotation, scale).
+///
+/// It might get more complicated as I add more ways to express rotation!
+///
 pub(crate) fn parse_save_transform(
     tokens: &Vec<Token>,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
-    // Tag(Transform),
+    if tokens.get(0) == Some(&Token::Tag("transform".into())) {
-    //      Tag(Translation), Number, Number, Number
+        let mut t = Transform::default();
-    //      Tag(Rotation), Number, Number, Number, Number
+        let mut idx = 1;
-    //      Tag(Scale), Number, Number, Number
+        while idx < tokens.len() {
-
+            match tokens.get(idx) {
-    // return Err(SaveEntityParseError::Transform);
+                Some(Token::Tag(attr)) => {
-
+                    idx += 1;
-    todo!("parse_save_transform");
+                    match attr.as_str() {
+                        "translation" => {
+                            if let Token::Num(x) = tokens[idx] {
+                                t.translation.x = x;
+                                idx += 1;
+                            }
+                            if let Token::Num(y) = tokens[idx] {
+                                t.translation.y = y;
+                                idx += 1;
+                            }
+                            if let Token::Num(z) = tokens[idx] {
+                                t.translation.z = z;
+                                idx += 1;
+                            }
+                            info!("{:?}", t.translation);
+                        }
+                        "scale" => {
+                            if let Token::Num(x) = tokens[idx] {
+                                t.scale.x = x;
+                                idx += 1;
+                            }
+                            if let Token::Num(y) = tokens[idx] {
+                                t.scale.y = y;
+                                idx += 1;
+                            }
+                            if let Token::Num(z) = tokens[idx] {
+                                t.scale.z = z;
+                                idx += 1;
+                            }
+                        }
+                        "rotation" => {
+                            let x = match tokens.get(idx) {
+                                Some(Token::Num(x)) => {
+                                    idx += 1;
+                                    *x
+                                }
+                                _ => 0.0,
+                            };
+                            let y = match tokens.get(idx) {
+                                Some(Token::Num(y)) => {
+                                    idx += 1;
+                                    *y
+                                }
+                                _ => 0.0,
+                            };
+                            let z = match tokens.get(idx) {
+                                Some(Token::Num(z)) => {
+                                    idx += 1;
+                                    *z
+                                }
+                                _ => 0.0,
+                            };
+                            let w = match tokens.get(idx) {
+                                Some(Token::Num(w)) => {
+                                    idx += 1;
+                                    *w
+                                }
+                                _ => 1.0,
+                            };
+                            t.rotation = Quat::from_xyzw(x, y, z, w);
+                        }
+                        _ => idx += 1,
+                    }
+                }
+                _ => idx += 1,
+            }
+        }
+        println!("Parsed transform: {:?}", t);
+        Ok(vec![
+            t.clone_value(),
+            GlobalTransform::default().clone_value(),
+        ])
+    } else {
+        return Err(SaveEntityParseError::Component("Transform".into()));
+    }
 }
 
 #[test]
 fn test_parse_transform() {
+    {
         let line = "transform translation 1.0 2.0 3.0 rotation 0.1 0.2 0.3 1.0 scale 1.1 1.2 1.3";
         let tokens = tokenize(line);
         let parsed = parse_save_transform(&tokens).unwrap();
-    let expected = Transform {
+        let t = Transform {
             translation: Vec3::new(1.0, 2.0, 3.0),
             rotation: Quat::from_xyzw(0.1, 0.2, 0.3, 1.0),
             scale: Vec3::new(1.1, 1.2, 1.3),
         };
+        let gt = GlobalTransform::default();
+        let expected = vec![t.clone_value(), gt.clone_value()];
 
-    assert!(expected
+        parsed.iter().zip(expected).for_each(|(p, e)| {
-        .clone_value()
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
-        .reflect_partial_eq(parsed.as_reflect())
+        });
-        .unwrap());
+    }
+    {
+        let line = "transform translation ... rotation ... scale ...";
+        let tokens = tokenize(line);
+        let parsed = parse_save_transform(&tokens).unwrap();
+        let t = Transform::default();
+        let gt = GlobalTransform::default();
+        let expected = vec![t.clone_value(), gt.clone_value()];
+
+        parsed.iter().zip(expected).for_each(|(p, e)| {
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+        });
+    }
+    {
+        let line = "transform ...";
+        let tokens = tokenize(line);
+        let parsed = parse_save_transform(&tokens).unwrap();
+        let t = Transform::default();
+        let gt = GlobalTransform::default();
+        let expected = vec![t.clone_value(), gt.clone_value()];
+
+        parsed.iter().zip(expected).for_each(|(p, e)| {
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+        });
+    }
+    {
+        let line = "transform translation 1.0 ... rotation 2.0 ... scale 3.0 ...";
+        let tokens = tokenize(line);
+        let parsed = parse_save_transform(&tokens).unwrap();
+        let t = Transform {
+            translation: Vec3::new(1.0, 0.0, 0.0),
+            rotation: Quat::from_xyzw(2.0, 0.0, 0.0, 1.0),
+            scale: Vec3::new(3.0, 1.0, 1.0),
+        };
+        let gt = GlobalTransform::default();
+        let expected = vec![t.clone_value(), gt.clone_value()];
+
+        parsed.iter().zip(expected).for_each(|(p, e)| {
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+        });
+    }
 }
 
 ///
@@ -115,11 +266,11 @@ fn test_parse_transform() {
 ///
 pub(crate) fn parse_save_name(
     tokens: &Vec<Token>,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
     if let Some((Token::Tag(t), &[Token::Str(ref s)])) = tokens.split_first()
         && *t == String::from("name")
     {
-        Ok(Name::new(s.clone()).clone_value())
+        Ok(vec![Name::new(s.clone()).clone_value()])
     } else {
         Err(SaveEntityParseError::Component("Name".into()))
     }
@@ -131,23 +282,21 @@ fn test_parse_name() {
         let line = "name Van";
         let tokens = tokenize(line);
         let parsed = parse_save_name(&tokens).unwrap();
-        let expected = Name::new("Van");
+        let expected = vec![Name::new("Van").clone_value()];
 
-        assert!(expected
+        parsed.iter().zip(expected).for_each(|(p, e)| {
-            .clone_value()
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
-            .reflect_partial_eq(parsed.as_reflect())
+        });
-            .unwrap());
     }
     {
         let line = "name Big Mike";
         let tokens = tokenize(line);
         let parsed = parse_save_name(&tokens).unwrap();
-        let expected = Name::new("Big Mike");
+        let expected = vec![Name::new("Big Mike").clone_value()];
 
-        assert!(expected
+        parsed.iter().zip(expected).for_each(|(p, e)| {
-            .clone_value()
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
-            .reflect_partial_eq(parsed.as_reflect())
+        });
-            .unwrap());
     }
 }
 
@@ -171,16 +320,24 @@ impl Component for SaveModel {
 ///
 pub(crate) fn parse_save_model(
     tokens: &Vec<Token>,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
-    todo!("parse_save_model");
+    if tokens.get(0) == Some(&Token::Tag("model".into())) {
-
+        if let Token::Str(gltf_file) = tokens.get(1).expect("model requires gltf file") {
-    /*
+            if let Token::Str(scene_name) = tokens.get(2).expect("model requires scene name") {
-    Ok(SaveModel {
+                Ok(vec![SaveModel {
-        gltf_file: gltf_path.into(),
+                    gltf_file: gltf_file.into(),
-        scene_name: scene_name.into(),
+                    scene_name: scene_name.clone(),
+                }
+                .clone_value()])
+            } else {
+                Err(SaveEntityParseError::Component("Model".into()))
+            }
+        } else {
+            Err(SaveEntityParseError::Component("Model".into()))
+        }
+    } else {
+        Err(SaveEntityParseError::Component("Model".into()))
     }
-    .clone_value())
-    */
 }
 
 #[test]
@@ -188,18 +345,17 @@ fn test_parse_model() {
     let line = "model \"models/foo.glb\" \"My Scene\"";
     let tokens = tokenize(line);
     let parsed = parse_save_model(&tokens).unwrap();
-    let expected = SaveModel {
+    let expected = vec![SaveModel {
         gltf_file: "models/foo.glb".into(),
         scene_name: "My Scene".into(),
-    };
+    }];
 
-    assert!(expected
+    parsed.iter().zip(expected).for_each(|(p, e)| {
-        .clone_value()
+        assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
-        .reflect_partial_eq(parsed.as_reflect())
+    });
-        .unwrap());
 }
 
-#[derive(Debug, Default, PartialEq, Reflect, Clone)]
+#[derive(Component, Debug, Default, PartialEq, Reflect, Clone)]
 #[reflect_value(Component, Default, PartialEq)]
 pub(crate) enum SaveCameraRenderTarget {
     #[default]
@@ -207,24 +363,29 @@ pub(crate) enum SaveCameraRenderTarget {
     Window(PathBuf),
 }
 
-impl Component for SaveCameraRenderTarget {
-    const STORAGE_TYPE: StorageType = StorageType::Table;
-
-    fn register_component_hooks(hooks: &mut ComponentHooks) {
-        todo!("Assign Render Target")
-    }
-}
-
 ///
-/// Returns a reflected `SaveCameraRenderTarget
+/// Returns a reflected `Camera3d`
 ///
 pub(crate) fn parse_save_camera(
     tokens: &Vec<Token>,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
-    todo!("parse_save_camera");
+    if tokens[0] == Token::Tag("camera".into()) {
-
+        Ok(vec![
-    // Nothing parsed well
+            Camera::default().clone_value(),
-    // Err(SaveEntityParseError::Camera)
+            CameraRenderGraph::new(Core3d).clone_value(),
+            Projection::default().clone_value(),
+            VisibleEntities::default().clone_value(),
+            Frustum::default().clone_value(),
+            Camera3d::default().clone_value(),
+            Tonemapping::default().clone_value(),
+            DebandDither::default().clone_value(),
+            ColorGrading::default().clone_value(),
+            Exposure::default().clone_value(),
+            CameraMainTextureUsages::default().clone_value(),
+        ])
+    } else {
+        Err(SaveEntityParseError::Component("camera".into()))
+    }
 }
 
 #[test]
@@ -233,44 +394,92 @@ fn test_parse_camera() {
         let line = "camera";
         let tokens = tokenize(line);
         let parsed = parse_save_camera(&tokens).unwrap();
-        let expected = SaveCameraRenderTarget::Default;
+        let expected = vec![
-        assert!(expected
+            Camera::default().clone_value(),
-            .clone_value()
+            CameraRenderGraph::new(Core3d).clone_value(),
-            .reflect_partial_eq(parsed.as_reflect())
+            Projection::default().clone_value(),
-            .unwrap());
+            VisibleEntities::default().clone_value(),
-    }
+            Frustum::default().clone_value(),
-    {
+            Camera3d::default().clone_value(),
-        let line = "camera target window";
+            Tonemapping::default().clone_value(),
-        let tokens = tokenize(line);
+            DebandDither::default().clone_value(),
-        let parsed = parse_save_camera(&tokens).unwrap();
+            ColorGrading::default().clone_value(),
-        let expected = SaveCameraRenderTarget::Default;
+            Exposure::default().clone_value(),
-        assert!(expected
+            CameraMainTextureUsages::default().clone_value(),
-            .clone_value()
+        ];
-            .reflect_partial_eq(parsed.as_reflect())
+        parsed
-            .unwrap());
+            .iter()
-    }
+            .zip(expected)
+            .for_each(|(p, e)| match e.reflect_partial_eq(p.as_reflect()) {
+                Some(r) => assert!(r),
+                None => warn!(
+                    "Type {:?} does not support reflection",
+                    e.get_represented_type_info().unwrap()
+                ),
+            });
+    }
+    //    {
+    //        let line = "camera target window";
+    //        let tokens = tokenize(line);
+    //        let parsed = parse_save_camera(&tokens).unwrap();
+    //        let expected = SaveCameraRenderTarget::Default;
+    //        assert!(expected
+    //            .clone_value()
+    //            .reflect_partial_eq(parsed.as_reflect())
+    //            .unwrap());
+    //    }
+    //    {
+    //        let line = "camera target";
+    //        let tokens = tokenize(line);
+    //        let parsed = parse_save_camera(&tokens);
+    //        assert!(parsed.is_err());
+    //    }
+    //    {
+    //        let line = "camera target window \"some.entity\"";
+    //        let tokens = tokenize(line);
+    //        let parsed = parse_save_camera(&tokens).unwrap();
+    //        let expected = SaveCameraRenderTarget::Window("some.entity".into());
+    //        assert!(expected
+    //            .clone_value()
+    //            .reflect_partial_eq(parsed.as_reflect())
+    //            .unwrap());
+    //    }
     {
-        let line = "camera target";
+        let line = "notcamera";
         let tokens = tokenize(line);
         let parsed = parse_save_camera(&tokens);
         assert!(parsed.is_err());
     }
-    {
-        let line = "camera target window \"some.entity\"";
-        let tokens = tokenize(line);
-        let parsed = parse_save_camera(&tokens).unwrap();
-        let expected = SaveCameraRenderTarget::Window("some.entity".into());
-        assert!(expected
-            .clone_value()
-            .reflect_partial_eq(parsed.as_reflect())
-            .unwrap());
 }
-    {
+
-        let line = "notcamera";
+/// encapsulates the spatial 3d bits of an entity
-        let tokens = tokenize(line);
+pub(crate) fn parse_save_visibility(
-        let parsed = parse_save_camera(&tokens);
+    tokens: &Vec<Token>,
-        assert!(parsed.is_err());
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
+    if tokens[0] == Token::Tag("visible".into()) {
+        Ok(vec![
+            Visibility::default().clone_value(),
+            InheritedVisibility::default().clone_value(),
+            ViewVisibility::default().clone_value(),
+        ])
+    } else {
+        Err(SaveEntityParseError::Component("visibility".into()))
+    }
 }
+
+#[test]
+fn test_parse_visibility() {
+    let line = "visible";
+    let tokens = tokenize(line);
+    let parsed = parse_save_visibility(&tokens).unwrap();
+    let expected = vec![
+        Visibility::default().clone_value(),
+        InheritedVisibility::default().clone_value(),
+        ViewVisibility::default().clone_value(),
+    ];
+    parsed.iter().zip(expected).for_each(|(p, e)| {
+        assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+    });
 }
 
 /// SaveParent entity which is a reference to which entity this is a child of

src/prelude.rs

@@ -10,8 +10,8 @@ pub(crate) use bevy::{
     window::{PrimaryWindow, WindowCloseRequested, WindowRef},
 };
 pub(crate) use nom::{
-    bytes::complete::take_until,
+    bytes::complete::{tag, take_until},
-    character::complete::{char, space0, alphanumeric1},
+    character::complete::{alphanumeric1, char, not_line_ending, space0},
     number::complete::float,
     sequence::tuple,
 };

src/save.rs

@@ -1,7 +1,9 @@
+use std::any::TypeId;
+
 use crate::prelude::*;
 
 type ParseFn =
-    for<'a> fn(&'a Vec<Token>) -> Result<Box<(dyn Reflect + 'static)>, SaveEntityParseError>;
+    for<'a> fn(&'a Vec<Token>) -> Result<Vec<Box<(dyn Reflect + 'static)>>, SaveEntityParseError>;
 
 /// Menu Plugin; contains parser functions
 pub(crate) struct SavePlugin {
@@ -51,7 +53,12 @@ pub(crate) struct SaveScene {
 // Ironically we basically want DynamicEntity: https://docs.rs/bevy/latest/bevy/scene/struct.DynamicEntity.html
 #[derive(Asset, TypePath, Default)]
 pub(crate) struct SaveEntity {
-    components: Vec<Box<dyn Reflect>>,
+    components: Vec<SaveEntityComponent>,
+}
+
+struct SaveEntityComponent {
+    type_id: TypeId,
+    data: Box<dyn Reflect>,
 }
 
 impl SaveEntity {
@@ -72,10 +79,20 @@ impl SaveEntity {
                 // Tokenize the line
                 let tokens = tokenize(line);
 
+                if matches!(tokens[0], Token::Comment(..)) {
+                    debug!("Skipping parsing comment line {:?}", tokens);
+                } else {
                     // Run line against all parsers
                     for f in fns {
-                    if let Ok(v) = f(&tokens) {
+                        if let Ok(p) = f(&tokens) {
-                        entity.components.push(v);
+                            p.iter().for_each(|c| {
+                                // Bundle the Type ID with this entry for auditing purposes
+                                let t = c.get_represented_type_info().unwrap().type_id();
+                                entity.components.push(SaveEntityComponent {
+                                    type_id: t,
+                                    data: c.clone_value(),
+                                });
+                            });
                             good = true;
                         }
                     }
@@ -87,7 +104,38 @@ impl SaveEntity {
                             "failed to parse component",
                         );
                     }
+                }
+            });
+        // Check for duplicate component types and emit an error
+        // TODO: It would be nice if this emitted a line refernece instead of a parsed struct!
+        let l = entity.components.len();
+        (0..l).for_each(|i| {
+            (i..l).for_each(|j| {
+                if i != j {
+                    let c1 = &entity.components[i];
+                    let c2 = &entity.components[j];
+                    let t1 = c1.type_id;
+                    let t2 = c2.type_id;
+                    if cfg!(debug_assertions) {
+                        debug_assert!(
+                            t1 != t2,
+                            "Duplicate components in {:?}: \n\t{:?}\n\t{:?}",
+                            load_context.asset_path(),
+                            c1.data,
+                            c2.data
+                        );
+                    } else {
+                        error!(
+                            "Duplicate components in {:?}: \n\t{:?}\n\t{:?}",
+                            load_context.asset_path(),
+                            c1.data,
+                            c2.data
+                        );
+                    }
+                }
             });
+        });
+
         Ok(entity)
     }
 }
@@ -163,6 +211,37 @@ impl AssetLoader for SaveSceneLoader {
             .map(|path| load_context.load(path))
             .collect();
 
+        // Assert there are no duplicate entities in the file
+        {
+            let l = entities.len();
+            (0..l).for_each(|i| {
+                (i..l).for_each(|j| {
+                    if i != j {
+                        let e1 = &entities[i];
+                        let e2 = &entities[j];
+                        if cfg!(debug_assertions) {
+                            debug_assert!(
+                                e1 != e2,
+                                "Duplicate entities in scene {:?}:\n\t{:?}\n\t{:?}",
+                                load_context.asset_path(),
+                                e1,
+                                e2
+                            );
+                        } else {
+                            if e1 == e2 {
+                                error!(
+                                    "Duplicate entities in scene {:?}:\n\t{:?}\n\t{:?}",
+                                    load_context.asset_path(),
+                                    e1,
+                                    e2
+                                )
+                            }
+                        }
+                    }
+                });
+            });
+        }
+
         Ok(SaveScene { entities })
     }
 
@@ -239,8 +318,8 @@ fn spawn_entities(
 
         // Add each component to the entity
         debug!("Populating entity with components {:?}", entity);
-        save_entity.components.iter().for_each(|component| {
+        save_entity.components.iter().for_each(|item| {
-            e.insert_reflect(component.clone_value());
+            e.insert_reflect(item.data.clone_value());
         });
     });
 }