Merge pull request #84 from bigladder/add-json-object-write

Add to_json boilerplate functions, recursive references.

Author: nealkruis

lattice/cpp/cpp_entries.py

@@ -14,6 +14,7 @@
     FunctionalHeaderEntry,
     HeaderEntry,
     InlineDependency,
+    ObjectDeserializationDeclaration,
     ObjectSerializationDeclaration,
     Struct,
     VirtualDestructor,
@@ -136,6 +137,17 @@ def __post_init__(self):
         self.trace()
 
 
+@dataclass
+class StructDeserialization(FunctionDefinition):
+    _header_entry: Struct
+
+    def __post_init__(self):
+        super(FunctionDefinition, self).__post_init__()
+        self._func = f"void to_json(nlohmann::json& j, const {self._name}& x)"
+
+        self.trace()
+
+
 @dataclass
 class MemberFunctionDefinition(FunctionDefinition):
     _header_entry: FunctionalHeaderEntry
@@ -193,6 +205,30 @@ def __post_init__(self):
         self.trace()
 
 
+@dataclass
+class OwnedElementDeserialization(ElementSerialization):
+    def __post_init__(self):
+        super().__post_init__()
+        self._funclines = [f'json_set<{self._type}>(j, "{self._name}", x.{self._name}, x.{self._name}_is_set);']
+        self.trace()
+
+
+@dataclass
+class OwnedElementDownload(ElementSerialization):
+    def __post_init__(self):
+        super().__post_init__()
+        self._funclines = []
+        assert len(self._header_entry.selector) == 1  # only one switchable data element per entry
+        data_element = next(iter(self._header_entry.selector))
+        for enum in self._header_entry.selector[data_element]:
+            self._funclines += [
+                f"if (x.{data_element} == {enum}) {{",
+                f'\tjson_set<{self._header_entry.selector[data_element][enum]}>(j, "{self._name}", *dynamic_cast<const {self._header_entry.selector[data_element][enum]}*>(x.{self._name}.get()), x.{self._name}_is_set);',  # noqa: E501
+                "}",
+            ]
+        self.trace()
+
+
 @dataclass
 class ClassFactoryCreation(ElementSerialization):
     def __post_init__(self):
@@ -268,14 +304,14 @@ def _translate(self, container_class_name, header_tree):
 
         self._get_items_to_serialize(header_tree.root)
 
-    def _get_items_to_serialize(self, header_tree: HeaderEntry):
+    def _get_items_to_serialize(self, header_tree: HeaderEntry):  # noqa: PLR0912 too-many-branches
         for h_entry in header_tree.child_entries:
             cpp_entry: Optional[ImplementationEntry] = None
             logger.debug(f"Header entry being processed: {h_entry.name} under {h_entry.parent.name}")
             if isinstance(h_entry, Struct) and len([c for c in h_entry.child_entries if isinstance(c, DataElement)]):
                 cpp_entry = StructSerialization(
                     h_entry, self._namespace
-                )  # Create the "from_json" function definition (header), only if it won't be empty
+                )  # Create the "from_json/"to_json"" function definition, only if they won't be empty
 
                 for data_element_entry in [c for c in h_entry.child_entries if isinstance(c, DataElement)]:
                     # In function body, create each "get_to" for individual data elements
@@ -284,6 +320,14 @@ def _get_items_to_serialize(self, header_tree: HeaderEntry):
                     else:
                         c = OwnedElementSerialization(data_element_entry, cpp_entry)
 
+                cpp_entry = StructDeserialization(h_entry, self._namespace)
+
+                for data_element_entry in [c for c in h_entry.child_entries if isinstance(c, DataElement)]:
+                    if "unique_ptr" in data_element_entry.type:
+                        c = OwnedElementDownload(data_element_entry, cpp_entry)
+                    else:
+                        c = OwnedElementDeserialization(data_element_entry, cpp_entry)
+
             elif isinstance(h_entry, DataElementStaticMetainfo):
                 logger.debug(f"{h_entry.name} under {type(h_entry.parent)} under {self._namespace._name}")
                 cpp_entry = DataElementStaticInitialization(h_entry, self._namespace)
@@ -295,6 +339,7 @@ def _get_items_to_serialize(self, header_tree: HeaderEntry):
             elif (
                 isinstance(h_entry, FunctionalHeaderEntry)
                 and not isinstance(h_entry, ObjectSerializationDeclaration)
+                and not isinstance(h_entry, ObjectDeserializationDeclaration)
                 and not isinstance(h_entry, VirtualDestructor)
             ):
                 cpp_entry = MemberFunctionDefinition(

lattice/cpp/header_entries.py

@@ -219,7 +219,6 @@ def _get_scoped_inner_type(self, type_str: str) -> str:
         # Look through the references to assign a scope to the type
         for custom_type in self._referenced_datatypes:
             if inner_type == custom_type.name:
-                print(f"{custom_type.namespace}", inner_type)
                 self.scoped_innertype = (f"{custom_type.namespace}", inner_type)
                 # namespace naming convention is snake_style, regardless of the schema file name
                 return "::".join(self.scoped_innertype)
@@ -372,6 +371,20 @@ def __post_init__(self):
         self.trace()
 
 
+@dataclass
+class ObjectDeserializationDeclaration(FunctionalHeaderEntry):
+    _f_ret: str = field(init=False)
+    _f_name: str = field(init=False)
+    _f_args: list[str] = field(init=False)
+
+    def __post_init__(self):
+        self._f_ret = "void"
+        self._f_name = "to_json"
+        self._f_args = ["nlohmann::json& j", f"const {self.name}& x"]
+        super().__post_init__()
+        self.trace()
+
+
 @dataclass
 class VirtualDestructor(FunctionalHeaderEntry):
     _explicit_definition: Optional[str] = None

lattice/cpp/header_translator.py

@@ -53,7 +53,7 @@ class HeaderTranslator:
     def __init__(
         self,
         input_file_path: Path,
-        forward_declarations_path: Path,
+        forward_declarations_path: Optional[Path],
         output_path: Path,
         top_namespace: str,
     ):
@@ -129,7 +129,7 @@ def _translate(self,
                                           "Description")
 
         for base_level_tag in self._list_objects_of_type("Data Group Template"):
-            predefined_code_dir: Path = self._forward_declaration_dir.parent / "cpp" / "base_classes"
+            predefined_code_dir: Path = self._source_dir.parent / "cpp" / "base_classes"
             base_class_file = Path(predefined_code_dir / f"{hyphen_separated_lowercase_style(base_level_tag)}.h")
             # TODO: Check naming assumptions and rules for pre-defined base class files
             if not base_class_file.exists():
@@ -170,9 +170,10 @@ def _translate(self,
                                          self._namespace,
                                          self._contents[base_level_tag]["Enumerators"])
         for base_level_tag in self._list_objects_of_type(self._data_group_types):
-            # from_json declarations are necessary in top container, as the header-declared
+            # from_json/to_json declarations are necessary in top container, as the header-declared
             # objects might be included and used from elsewhere.
             ObjectSerializationDeclaration(base_level_tag, self._namespace)
+            ObjectDeserializationDeclaration(base_level_tag, self._namespace)
 
     def _reset_parsing(self):
         """Clear member containers for a new translation."""
@@ -220,6 +221,8 @@ def _load_meta_info(self, schema_section):
                 self._fundamental_data_types[base_item] = cpp_types[ext_dict[base_item]["JSON Schema Type"]]
             for base_item in [name for name in ext_dict if ext_dict[name]["Object Type"] == "String Type"]:
                 self._fundamental_data_types[base_item] = "std::string"
+            if reference_name not in [self._schema_name, "core"]:
+                self._load_meta_info(ext_dict["Schema"]) # Recursively collect references, as C++ does
     # fmt: on
 
     def _add_include_guard(self, header_name):

lattice/cpp/templates/load-object.h.j2

@@ -73,6 +73,19 @@ namespace {{namespace}} {
             }
         }
     }
+
+    template<class T>
+    void json_set(nlohmann::json &j,
+                  const char *subnode,
+                  const T& object,
+                  bool object_is_set
+                  )
+    {
+        if (object_is_set)
+        {
+            j[subnode] = object;
+        }
+    }
 }
 
 #endif

lattice/lattice.py

@@ -260,9 +260,7 @@ def cpp_support_headers(self) -> list[Path]:
     def generate_cpp_project(self):
         """Generate CPP header files, source files, and build support files."""
         for schema in self.cpp_schemas:
-            h = HeaderTranslator(
-                schema.file_path, self.schema_directory_path, self._cpp_output_include_dir, self.root_directory.name
-            )
+            h = HeaderTranslator(schema.file_path, None, self._cpp_output_include_dir, self.root_directory.name)
             string_to_file(str(h), schema.cpp_header_file_path)
             c = CPPTranslator(self.root_directory.name, h)
             string_to_file(str(c), schema.cpp_source_file_path)