Orchestrate communication between RbxSession and VfsSession

server/src/rbx_session.rs

@@ -1,43 +1,93 @@
 use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
 
-use id::Id;
+use file_route::FileRoute;
+use id::{Id, get_id};
 use partition::Partition;
 use rbx::RbxInstance;
 use session::SessionConfig;
+use vfs_session::{VfsSession, FileItem};
+
+fn file_to_instances(file_item: &FileItem, partition: &Partition, output: &mut HashMap<Id, RbxInstance>) -> Id {
+    match file_item {
+        FileItem::File { contents, route } => {
+            let mut properties = HashMap::new();
+            properties.insert("Value".to_string(), contents.clone());
+
+            let primary_id = get_id();
+
+            output.insert(primary_id, RbxInstance {
+                name: route.name(partition).to_string(),
+                class_name: "StringValue".to_string(),
+                parent: None,
+                properties,
+            });
+
+            primary_id
+        },
+        FileItem::Directory { children, route } => {
+            let primary_id = get_id();
+
+            output.insert(primary_id, RbxInstance {
+                name: route.name(partition).to_string(),
+                class_name: "Folder".to_string(),
+                parent: None,
+                properties: HashMap::new(),
+            });
+
+            for child_file_item in children.values() {
+                let mut child_instances = HashMap::new();
+                let child_id = file_to_instances(child_file_item, partition, &mut child_instances);
+
+                child_instances.get_mut(&child_id).unwrap().parent = Some(primary_id);
+
+                for (instance_id, instance) in child_instances.drain() {
+                    output.insert(instance_id, instance);
+                }
+            }
+
+            primary_id
+        }
+    }
+}
 
 pub struct RbxSession {
-    pub config: SessionConfig,
+    config: SessionConfig,
+
+    vfs_session: Arc<RwLock<VfsSession>>,
 
     /// The RbxInstance that represents each partition.
-    pub partition_instances: HashMap<String, Id>,
+    partition_instances: HashMap<String, Id>,
 
     /// The store of all instances in the session.
-    pub instances: HashMap<Id, RbxInstance>,
+    instances: HashMap<Id, RbxInstance>,
 
-    // pub instances_by_route: HashMap<FileRoute, Id>,
+    // instances_by_route: HashMap<FileRoute, Id>,
 }
 
 impl RbxSession {
-    pub fn new(config: SessionConfig) -> RbxSession {
+    pub fn new(config: SessionConfig, vfs_session: Arc<RwLock<VfsSession>>) -> RbxSession {
         RbxSession {
             config,
+            vfs_session,
             partition_instances: HashMap::new(),
             instances: HashMap::new(),
+            // instances_by_route: HashMap::new(),
         }
     }
 
-    // fn load_instances(&mut self) {
-    //     for (partition_name, file_item) in &self.partition_files {
-    //         let partition = self.partitions.get(partition_name).unwrap();
-    //         let (root_id, mut instances) = file_to_instance(&file_item, partition);
+    pub fn read_partitions(&mut self) {
+        let vfs_session = self.vfs_session.read().unwrap();
 
-    //         // there has to be an std method for this
-    //         // oh well
-    //         for (instance_id, instance) in instances.drain() {
-    //             self.instances.insert(instance_id, instance);
-    //         }
+        for partition in self.config.partitions.values() {
+            let route = FileRoute {
+                partition: partition.name.clone(),
+                route: Vec::new(),
+            };
+            let file_item = vfs_session.get_file_item(&route).unwrap();
+            let root_id = file_to_instances(file_item, partition, &mut self.instances);
 
-    //         self.partition_instances.insert(partition_name.clone(), root_id);
-    //     }
-    // }
+            self.partition_instances.insert(partition.name.clone(), root_id);
+        }
+    }
 }