Corrected issues with english version of RDF Triples. Working on generating oxrdf::graph out of the values

Author: bharath181

Cargo.lock

@@ -10,3 +10,4 @@ petgraph = "0.6.5"
 serde = "1.0.203"
 serde_json = "1.0.117"
 struson = "0.5.0"
+uuid = { version = "1", features = ["v4"] }

Cargo.toml

@@ -1,70 +1,74 @@
-use oxrdf::{Graph, NamedOrBlankNode};
+use oxrdf::vocab::xsd;
+use oxrdf::{
+    graph, BlankNode, Graph, Literal, NamedNode, NamedNodeRef, NamedOrBlankNode, Term, TermRef,
+    TripleRef,
+};
 use serde::de::value;
 use serde_json::{Deserializer, Value};
 use std::collections::{HashMap, VecDeque};
+use std::fmt::format;
 use std::fs::File;
 use std::io::BufReader;
+use uuid::Uuid;
 
 fn main() {
     let file = File::open("src/airplane.json").unwrap();
     let reader = BufReader::new(file);
     let stream = Deserializer::from_reader(reader).into_iter::<Value>();
 
-    let mut subject_stack: VecDeque<String> = VecDeque::new();
-    let mut array_properties: HashMap<String, String> = HashMap::new();
+    let mut graph = Graph::default();
+
+    let mut subject_stack: VecDeque<BlankNode> = VecDeque::new();
     let mut property: Option<String> = None;
 
     for value in stream {
         match value {
             Ok(Value::Object(obj)) => {
-                let subject = format!("_:b{}", subject_stack.len()); // Create a new blank node
-                println!("Created new subject: {}", subject);
+                let subject = BlankNode::default(); // Create a new blank node
                 subject_stack.push_back(subject.clone());
 
-                if let Some(last_subject) = subject_stack.back() {
-                    println!("The last subject in the stack is: {}", last_subject);
-                    if let Some(prop) = &property {
-                        println!("Adding property for parent -> child relationship: {}", prop);
-                    }
-                }
-
                 for (key, val) in obj {
-                    property = Some(format!("#{}", key));
-                    println!("Processing key: {}", key);
-                    process_value(&mut subject_stack, &property, val);
+                    property = Some(format!("https://decisym/json2rdf/#{}", key));
+                    process_value(&mut subject_stack, &property, val, &mut graph);
                 }
 
-                // End of object; remove the subject from stack
                 subject_stack.pop_back();
             }
             Ok(Value::Array(arr)) => {
-                if let Some(last_subject) = subject_stack.back() {
-                    if let Some(prop) = &property {
-                        array_properties.insert(last_subject.clone(), prop.clone());
-                    }
-                }
                 for val in arr {
-                    process_value(&mut subject_stack, &property, val);
+                    process_value(&mut subject_stack, &property, val, &mut graph);
                 }
             }
             Ok(other) => {
-                process_value(&mut subject_stack, &property, other);
+                process_value(&mut subject_stack, &property, other, &mut graph);
             }
             Err(e) => {
                 eprintln!("Error parsing JSON: {}", e);
             }
         }
     }
+
+    
 }
 
-fn process_value(subject_stack: &mut VecDeque<String>, property: &Option<String>, value: Value) {
-    if let Some(last_subject) = subject_stack.back() {
-        println!("The last subject in the stack is: {}", last_subject);
+fn process_value(
+    subject_stack: &mut VecDeque<BlankNode>,
+    property: &Option<String>,
+    value: Value,
+    graph: &mut Graph,
+) {
+    if let Some(last_subject) = subject_stack.clone().back() {
         if let Some(prop) = property {
-            println!("Processing property: {}", prop);
+            // println!("Processing property: {}", prop);
             match value {
                 Value::Bool(b) => {
-                    println!("Boolean value: {}", b);
+                    // println!("{},{},{}", subject_stack.back().unwrap(), prop, b);
+
+                    graph.insert(TripleRef::new(
+                        subject_stack.back().unwrap(),
+                        NamedNodeRef::new(prop.as_str()).unwrap(),
+                        &Literal::new_typed_literal(b.to_string(), xsd::BOOLEAN),
+                    ));
                 }
                 Value::Number(num) => {
                     let literal = if let Some(int) = num.as_i64() {
@@ -74,27 +78,50 @@ fn process_value(subject_stack: &mut VecDeque<String>, property: &Option<String>
                     } else {
                         return;
                     };
-                    println!("Number value: {}", literal);
+                    // println!("{},{},{}", subject_stack.back().unwrap(), prop, literal);
+                    graph.insert(TripleRef::new(
+                        subject_stack.back().unwrap(),
+                        NamedNodeRef::new(prop.as_str()).unwrap(),
+                        &Literal::new_typed_literal(literal, xsd::INT),
+                    ));
                 }
                 Value::String(s) => {
-                    println!("String value: {}", s);
+                    //println!("{},{},{}", subject_stack.back().unwrap(), prop, s);
+                    graph.insert(TripleRef::new(
+                        subject_stack.back().unwrap(),
+                        NamedNodeRef::new(prop.as_str()).unwrap(),
+                        &Literal::new_typed_literal(s, xsd::STRING),
+                    ));
                 }
                 Value::Null => {
                     println!("Null value");
                 }
                 Value::Object(obj) => {
-                    let subject = format!("_:b{}", subject_stack.len());
-                    println!("Created nested subject: {}", subject);
+                    let subject = BlankNode::default();
                     subject_stack.push_back(subject);
+
+                    // println!(
+                    //     "{},{},{}",
+                    //     last_subject,
+                    //     prop,
+                    //     subject_stack.back().unwrap()
+                    // );
+
+                    graph.insert(TripleRef::new(
+                        subject_stack.back().unwrap(),
+                        NamedNodeRef::new(prop.as_str()).unwrap(),
+                        subject_stack.back().unwrap(),
+                    ));
+
                     for (key, val) in obj {
                         let nested_property = Some(format!("#{}", key));
-                        process_value(subject_stack, &nested_property, val);
+                        process_value(subject_stack, &nested_property, val, graph);
                     }
                     subject_stack.pop_back();
                 }
                 Value::Array(arr) => {
                     for val in arr {
-                        process_value(subject_stack, property, val);
+                        process_value(subject_stack, property, val, graph);
                     }
                 }
             }