ddl: working C++ backend

4 files changed, 78 insertions, 36 deletions

diff --git a/Language.hs b/Language.hs
index 6a5cc33..e7ef163 100644
--- a/Language.hs
+++ b/Language.hs
@@ -230,7 +230,9 @@ cppType aliasMap = \case
   Maybe t       -> "Maybe<" ++ cppType aliasMap t ++ ">"
   Map k v       -> "std::map<" ++ cppType aliasMap k ++ ", " ++ cppType aliasMap v ++ ">"
   -- user defined
-  Data t        -> "::" ++ t
+  Data t        -> case normalize aliasMap (Data t) of
+    Data n  -> "std::shared_ptr<::" ++ n ++ ">"
+    _       -> "::" ++ t
   x -> error $ "unknown type: " ++ show x
 
 hasFieldNames :: [Field] -> Bool
diff --git a/lib/RT.cpp b/lib/RT.cpp
index 741596c..97701b2 100644
--- a/lib/RT.cpp
+++ b/lib/RT.cpp
@@ -21,23 +21,22 @@ template<> json toJSON<unsigned int>(unsigned int &v) {
 }
 
 template<> String fromJSON<String>(W<String> v, json &obj) {
-  String s;
-  return s;
+  return obj.get<String>();
 }
 
 template<> Float fromJSON<Float>(W<Float> v, json &obj) {
-  return 0.0;
+  return obj.get<Float>();
 }
 
 template<> bool fromJSON<bool>(W<bool> v, json &obj) {
-  return false;
+  return obj.get<bool>();
 }
 
 template<> int fromJSON<int>(W<int> v, json &obj) {
-  return 0;
+  return obj.get<int>();
 }
 
 template<> unsigned int fromJSON<unsigned int>(W<unsigned int> v, json &obj) {
-  return 0;
+  return obj.get<unsigned int>();
 }
 
diff --git a/lib/RT.hpp b/lib/RT.hpp
index d34557e..2e1e652 100644
--- a/lib/RT.hpp
+++ b/lib/RT.hpp
@@ -63,23 +63,38 @@ template<typename T>
 json toJSON(T &v);
 
 template<typename any>
-json toJSON(Maybe<any> &value) {
+json toJSON(Maybe<any> &v) {
+  if (v.valid) {
+    return toJSON(v.data);
+  }
   return json();
 }
 
 template<typename any>
-json toJSON(V2<any> &value) {
-  return json();
+json toJSON(V2<any> &v) {
+  json obj({});
+  obj["x"] = toJSON(v.x);
+  obj["y"] = toJSON(v.y);
+  return obj;
 }
 
 template<typename any>
-json toJSON(V3<any> &value) {
-  return json();
+json toJSON(V3<any> &v) {
+  json obj({});
+  obj["x"] = toJSON(v.x);
+  obj["y"] = toJSON(v.y);
+  obj["z"] = toJSON(v.z);
+  return obj;
 }
 
 template<typename any>
-json toJSON(V4<any> &value) {
-  return json();
+json toJSON(V4<any> &v) {
+  json obj({});
+  obj["x"] = toJSON(v.x);
+  obj["y"] = toJSON(v.y);
+  obj["z"] = toJSON(v.z);
+  obj["w"] = toJSON(v.w);
+  return obj;
 }
 
 template<typename any>
@@ -91,9 +106,13 @@ json toJSON(std::vector<any> &v) {
   return obj;
 }
 
-template<typename k, typename v>
-json toJSON(std::map<k,v> &value) {
-  return json();
+template<typename v>
+json toJSON(std::map<String,v> &value) {
+  json obj({});
+  for(auto i : value) {
+    obj[i.first] = toJSON(i.second);
+  }
+  return obj;
 }
 
 template<typename T>
@@ -105,37 +124,65 @@ T fromJSON(W<T> w, json &obj);
 template<typename any>
 Maybe<any> fromJSON(W<Maybe<any>> v, json &obj) {
   Maybe<any> a;
+  if (obj.is_null()) {
+    a.valid = false;
+  } else {
+    a.valid = true;
+    a.data = fromJSON(W<any>(),obj);
+  }
   return a;
 }
 
 template<typename any>
 V2<any> fromJSON(W<V2<any>> v, json &obj) {
   V2<any> a;
+  a.x = fromJSON(W<any>(), obj["x"]);
+  a.y = fromJSON(W<any>(), obj["y"]);
   return a;
 }
 
 template<typename any>
 V3<any> fromJSON(W<V3<any>> v, json &obj) {
   V3<any> a;
+  a.x = fromJSON(W<any>(), obj["x"]);
+  a.y = fromJSON(W<any>(), obj["y"]);
+  a.z = fromJSON(W<any>(), obj["z"]);
   return a;
 }
 
 template<typename any>
 V4<any> fromJSON(W<V4<any>> v, json &obj) {
   V4<any> a;
+  a.x = fromJSON(W<any>(), obj["x"]);
+  a.y = fromJSON(W<any>(), obj["y"]);
+  a.z = fromJSON(W<any>(), obj["z"]);
+  a.w = fromJSON(W<any>(), obj["w"]);
   return a;
 }
 
 template<typename any>
 std::vector<any> fromJSON(W<std::vector<any>> v, json &obj) {
   std::vector<any> a;
+  for (json::iterator it = obj.begin(); it != obj.end(); ++it) {
+    a.push_back(fromJSON(W<any>(),*it));
+  }
   return a;
 }
 
+template<typename v>
+std::map<String,v> fromJSON(W<std::map<String,v>> value, json &obj) {
+  std::map<String,v> a;
+  for (json::iterator it = obj.begin(); it != obj.end(); ++it) {
+    a[it.key()] = fromJSON(W<v>(),it.value());
+  }
+  return a;
+}
+
+/*
 template<typename k, typename v>
 std::map<k,v> fromJSON(W<std::map<k,v>> value, json &obj) {
   std::map<k,v> a;
   return a;
 }
-
+*/
 #endif
\ No newline at end of file
diff --git a/templates/data.cpp.ede b/templates/data.cpp.ede
index 2b3e865..39bf39d 100644
--- a/templates/data.cpp.ede
+++ b/templates/data.cpp.ede
@@ -1,46 +1,40 @@
 // generated file, do not modify!
 // {{ dateTime }}
 
-#include <string>
-#include <iostream>
-
 #include "{{ moduleName }}.hpp"
-
 {% for t in definitions %}
-template<> json toJSON<{{ t.value.dataName }}>({{ t.value.dataName }} &v) {
-  json obj;
-  switch (v.tag) { {% for c in t.value.constructors %}
+template<> json toJSON<std::shared_ptr<{{ t.value.dataName }}>>(std::shared_ptr<{{ t.value.dataName }}> &v) {
+  json obj({});
+  switch (v->tag) { {% for c in t.value.constructors %}
     case ::{{ t.value.dataName }}::tag::{{ c.value.name }}:
       obj["tag"] = "{{ c.value.name }}";{% if !(c.value.fields | empty) %}
       {
-        auto tv = static_cast<::data::{{ c.value.name }}&>(v);{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
-        obj["{{ f.value.fieldName }}"] = toJSON(tv.{{ f.value.fieldName }});{% else %}
-        obj["arg{{ f.index0 }}"] = toJSON(tv._{{ f.index0 }});{% endif %}{% endfor %}
+        std::shared_ptr<data::{{ c.value.name }}> tv = std::static_pointer_cast<data::{{ c.value.name }}>(v);{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+        obj["{{ f.value.fieldName }}"] = toJSON(tv->{{ f.value.fieldName }});{% else %}
+        obj["arg{{ f.index0 }}"] = toJSON(tv->_{{ f.index0 }});{% endif %}{% endfor %}
       }{% endif %}
       break;{% endfor %}
   }
   return obj;
 }
 
-template<> {{ t.value.dataName }} fromJSON<{{ t.value.dataName }}>(W<{{ t.value.dataName }}> v, json &obj) {
-  std::cout << "fromJSON: {{ t.value.dataName }}\n";
+template<> std::shared_ptr<{{ t.value.dataName }}> fromJSON<std::shared_ptr<{{ t.value.dataName }}>>(W<std::shared_ptr<{{ t.value.dataName }}>> v, json &obj) {
   enum ::{{ t.value.dataName }}::tag tagType;
   std::string tag = obj["tag"];
   {% for c in t.value.constructors %}
   {% if !c.first %}else {% endif %}if (tag == "{{ c.value.name }}") {
     tagType = ::{{ t.value.dataName }}::tag::{{ c.value.name }};
     {% if !(c.value.fields | empty) %}
-    ::data::{{ c.value.name }} tv;
-    tv.tag = tagType;{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
-    tv.{{ f.value.fieldName }} = fromJSON(W<{{ f.value.fieldType | cppType }}>(), obj["{{ f.value.fieldName }}"]);{% else %}
-    tv._{{ f.index0 }} = fromJSON(W<{{ f.value.fieldType | cppType }}>(), obj["arg{{ f.index0 }}"]);{% endif %}{% endfor %}
+    std::shared_ptr<data::{{ c.value.name }}> tv(new data::{{ c.value.name }}());{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+    tv->{{ f.value.fieldName }} = fromJSON(W<{{ f.value.fieldType | cppType }}>(), obj["{{ f.value.fieldName }}"]);{% else %}
+    tv->_{{ f.index0 }} = fromJSON(W<{{ f.value.fieldType | cppType }}>(), obj["arg{{ f.index0 }}"]);{% endif %}{% endfor %}
     return tv;
     {% endif %}
   }
 {% endfor %}
   else throw "unknown constructor: " + tag;
-  {{ t.value.dataName }} o;
-  o.tag = tagType;
+  std::shared_ptr<::{{ t.value.dataName }}> o(new ::{{ t.value.dataName }}());
+  o->tag = tagType;
   return o;
 }