fixed beffer overflow in vector. Added serialize and deserialize in json with vector reading from the struct with json

1 files changed, 128 insertions, 63 deletions

diff --git a/examples/data/json_config.zc b/examples/data/json_config.zc
index ccfb1a2..f6283b2 100644
--- a/examples/data/json_config.zc
+++ b/examples/data/json_config.zc
@@ -5,15 +5,21 @@ import "std/map.zc"
 import "std/option.zc"
 import "std/string.zc"
 import "std/core.zc"
+import "std/vec.zc"
 
-raw {
-    typedef struct JsonValue* JsonValuePtr;
+@derive(FromJson, ToJson)
+struct Features {
+    logging: bool;
+    metrics: bool;
 }
 
+@derive(FromJson, ToJson)
 struct Config {
     server_name: String;
     port: int;
-    logging: bool;
+    max_connections: int;
+    features: Features;
+    allowed_hosts: Vec<String>;
 }
 
 fn main() {
@@ -24,76 +30,135 @@ fn main() {
         !"Failed to read config file: {content_res.err}";
         return 1;
     }
-    
-    var json_str = content_res.unwrap();
 
-    var json_res = JsonValue::parse(json_str.c_str());
-    if json_res.is_err() {
-        !"JSON Parse Error: {json_res.err}";
+    var json_str = content_res.unwrap();
+    var parse_res = JsonValue::parse(json_str.c_str());
+    if parse_res.is_err() {
+        !"JSON Parse Error";
         json_str.free();
         return 1;
     }
-    
-    var root = json_res.unwrap();
-    
-    defer {
-        json_str.free();
-        JsonValue::free(root);
-        free(root);
-    }
-    
-    if (*root).kind.tag != JsonType::JSON_OBJECT().tag {
-         !"Expected JSON Object at root";
-         return 1;
-    }
-    
-    var config = Config { 
-        server_name: String::new("Unknown"), 
-        port: 0, 
-        logging: false 
-    };
-
-    var obj_map = (*root).object_val;
-
-    if Map<JsonValue*>::contains(obj_map, "server_name") {
-        var opt = Map<JsonValue*>::get(obj_map, "server_name");
-        var val = opt.unwrap();
-        if (*val).kind.tag == JsonType::JSON_STRING().tag {
-            config.server_name.free();
-            config.server_name = String::new((*val).string_val);
-        }
-    }
-    
-    if Map<JsonValue*>::contains(obj_map, "port") {
-        var opt = Map<JsonValue*>::get(obj_map, "port");
-        var val = opt.unwrap();
-        if (*val).kind.tag == JsonType::JSON_NUMBER().tag {
-            config.port = (int)(*val).number_val;
-        }
+
+    var root = parse_res.unwrap();
+
+    // ============================================
+    // Demo 1: Using accessor methods
+    // ============================================
+    "=== Accessor methods ===";
+
+    var server_opt = (*root).get_string("server_name");
+    var server = server_opt.unwrap_or("default");
+
+    var port_opt = (*root).get_int("port");
+    var port = port_opt.unwrap_or(8080);
+
+    var max_conn_opt = (*root).get_int("max_connections");
+    var max_conn = max_conn_opt.unwrap_or(10);
+
+    var logging = false;
+    var metrics = false;
+    var features_opt = (*root).get_object("features");
+    if features_opt.is_some() {
+        var features = features_opt.unwrap();
+        var logging_opt = features.get_bool("logging");
+        logging = logging_opt.unwrap_or(false);
+        var metrics_opt = features.get_bool("metrics");
+        metrics = metrics_opt.unwrap_or(false);
     }
-    
-    if Map<JsonValue*>::contains(obj_map, "features") {
-        var opt = Map<JsonValue*>::get(obj_map, "features");
-        var features = opt.unwrap();
-        if (*features).kind.tag == JsonType::JSON_OBJECT().tag {
-            var f_obj = (*features).object_val;
-            if Map<JsonValue*>::contains(f_obj, "logging") {
-                var l_opt = Map<JsonValue*>::get(f_obj, "logging");
-                var l = l_opt.unwrap();
-                if (*l).kind.tag == JsonType::JSON_BOOL().tag {
-                    config.logging = (*l).bool_val;
+
+    "Server:          {server}";
+    "Port:            {port}";
+    "Max Connections: {max_conn}";
+    "Logging:         {logging}";
+    "Metrics:         {metrics}";
+
+    // Reading array: allowed_hosts
+    var hosts_opt = (*root).get_array("allowed_hosts");
+    if hosts_opt.is_some() {
+        var hosts = hosts_opt.unwrap();
+        var count = hosts.len();
+        "Allowed Hosts:   ({count} entries)";
+        for var i: usize = 0; i < count; i = i + 1 {
+            var host_opt = hosts.at(i);
+            if host_opt.is_some() {
+                var host_val = host_opt.unwrap();
+                var host_str = (*host_val).as_string();
+                if host_str.is_some() {
+                    var h = host_str.unwrap();
+                    "  - {h}";
                 }
             }
         }
     }
-    
-    "Configuration Loaded:";
+
+    // ============================================
+    // Demo 2: from_json / to_json
+    // ============================================
+    "";
+    "=== @derive(FromJson, ToJson) ===";
+
+    var config_res = Config::from_json(root);
+    var config = config_res.unwrap();
+
     var s_name = config.server_name.c_str();
-    "Server:  {s_name}";
-    "Port:    {config.port}";
-    "Logging: {config.logging}";
-    
+    "Config from JSON:";
+    "  server_name:     {s_name}";
+    "  port:            {config.port}";
+    "  max_connections: {config.max_connections}";
+    "  features.logging: {config.features.logging}";
+    "  features.metrics: {config.features.metrics}";
+    var hosts_count = config.allowed_hosts.length();
+    "  allowed_hosts:   ({hosts_count} entries)";
+    for var i: usize = 0; i < hosts_count; i = i + 1 {
+        var host = config.allowed_hosts.get(i).c_str();
+        "    - {host}";
+    }
+
+    // Serialize back to JSON
+    var json_out = config.to_json();
+
+    var out_name_opt = json_out.get_string("server_name");
+    var out_name = out_name_opt.unwrap_or("?");
+
+    var out_port_opt = json_out.get_int("port");
+    var out_port = out_port_opt.unwrap_or(0);
+
+    var out_features_opt = json_out.get_object("features");
+    var out_logging = false;
+    var out_metrics = false;
+    if out_features_opt.is_some() {
+        var out_features = out_features_opt.unwrap();
+        var logging_opt = out_features.get_bool("logging");
+        out_logging = logging_opt.unwrap_or(false);
+        var metrics_opt = out_features.get_bool("metrics");
+        out_metrics = metrics_opt.unwrap_or(false);
+    }
+
+    // Check allowed_hosts in serialized output
+    var out_hosts_opt = json_out.get_array("allowed_hosts");
+    var out_hosts_count: usize = 0;
+    if out_hosts_opt.is_some() {
+        out_hosts_count = out_hosts_opt.unwrap().len();
+    }
+
+    "";
+    "Round-trip to_json:";
+    "  server_name: {out_name}";
+    "  port:        {out_port}";
+    "  features.logging: {out_logging}";
+    "  features.metrics: {out_metrics}";
+    "  allowed_hosts: {out_hosts_count} entries";
+
+    // Cleanup
     config.server_name.free();
-    
+    for var i: usize = 0; i < config.allowed_hosts.length(); i = i + 1 {
+        config.allowed_hosts.get(i).free();
+    }
+    config.allowed_hosts.free();
+    json_out.free();
+    json_str.free();
+    JsonValue::free(root);
+    free(root);
+
     return 0;
 }