added cpp serializer

Author: drblallo

python/rlc/renderer/__init__.py

@@ -1,2 +1,9 @@
-
 from rlc.renderer.factory import RendererFactory
+from .array_renderer import ArrayRenderer
+from .bint_renderer import BoundedIntRenderer
+from .vector_renderer import VectorRenderer
+from .struct_renderer import ContainerRenderer
+from .primitive_renderer import PrimitiveRenderer
+from .vector_renderer import VectorRenderer
+from .renderable import Renderable
+from .cpp_serializer import SerializationContext

python/rlc/renderer/bounded_vector_renderer.py

@@ -20,3 +20,6 @@ def build_layout(self, obj, direction=Direction.COLUMN,
     def update(self, layout, obj, elapsed_time=0.0):
         value = getattr(obj, "_data")
         self.vector_renderer.update(layout, value, elapsed_time)
+
+    def _iter_children(self) :
+        return [self.vector_renderer]

python/rlc/renderer/cpp_serializer.py

@@ -0,0 +1,123 @@
+from functools import singledispatchmethod
+from .array_renderer import ArrayRenderer
+from .bint_renderer import BoundedIntRenderer
+from .vector_renderer import VectorRenderer
+from .struct_renderer import ContainerRenderer
+from .primitive_renderer import PrimitiveRenderer
+from .vector_renderer import VectorRenderer
+from .renderable import Renderable
+from dataclasses import dataclass
+from typing import TextIO
+
+class Indenter:
+    def __init__(self, ctx: 'SerializationContext'):
+        self.ctx = ctx
+
+    def __enter__(self):
+        self.ctx.current_indent = self.ctx.current_indent + 1
+
+    def __exit__(self, *args):
+        self.ctx.current_indent = self.ctx.current_indent - 1
+
+@dataclass
+class SerializationContext:
+    outstream: TextIO
+    current_indent: int = 0
+    start_of_line: bool = False
+
+    def write(self, string):
+        if self.start_of_line:
+            self._do_indent()
+            self.start_of_line = False
+        self.outstream.write(string)
+
+    def writenl(self, string):
+        self.outstream.write(string)
+        self.endline()
+
+    def endline(self):
+        self.outstream.write("\n")
+        self.start_of_line = True
+
+    def _do_indent(self):
+        for i in range(self.current_indent):
+            self.outstream.write(" ")
+
+    def indent(self):
+        return Indenter(self)
+
+    def write_type_unique_id(self, renderer_type: Renderable):
+        if hasattr(renderer_type, "name"):
+            if renderer_type.name != "":
+                self.write(renderer_type.name + "Renderer")
+            else:
+                self.write("anon_" + str(id(renderer_type)))
+        else:
+            self.write(type(renderer_type).__name__)
+
+
+    @singledispatchmethod
+    def serialize_declaration(self, renderer_type: Renderable):
+        self.write(str(renderer_type))
+        raise NotImplementedError()
+
+    @serialize_declaration.register
+    def _(self, renderer_type: ArrayRenderer):
+        pass
+
+    @serialize_declaration.register
+    def _(self, renderer_type: BoundedIntRenderer):
+        pass
+
+    @serialize_declaration.register
+    def _(self, renderer_type: PrimitiveRenderer):
+        pass
+
+    @serialize_declaration.register
+    def _(self, renderer_type: VectorRenderer):
+        pass
+
+    @serialize_declaration.register
+    def _(self, renderer_type: ContainerRenderer):
+        self.write("class ")
+        self.write_type_unique_id(renderer_type)
+        self.writenl(" {")
+        with self.indent() as indenter:
+            for field_name, renderer in renderer_type.field_renderers.items():
+                self.serialize_use(renderer)
+                self.write(" ")
+                self.write(field_name)
+                self.write(";")
+                self.endline()
+        self.writenl("};");
+
+    @singledispatchmethod
+    def serialize_use(self, renderer_type: Renderable):
+        self.write(str(renderer_type))
+        raise NotImplementedError()
+
+    @serialize_use.register
+    def _(self, renderer_type: ArrayRenderer):
+        self.write("ArrayRenderer<")
+        self.serialize_use(renderer_type.element_renderer)
+        self.write(", ")
+        self.write(str(renderer_type.length))
+        self.write(">")
+
+    @serialize_use.register
+    def _(self, renderer_type: BoundedIntRenderer):
+        self.write("BoundedIntRenderer")
+
+    @serialize_use.register
+    def _(self, renderer_type: PrimitiveRenderer):
+        self.write("PrimitiveRenderer")
+
+    @serialize_use.register
+    def _(self, renderer_type: VectorRenderer):
+        self.write("VectorRenderer<")
+        self.serialize_use(renderer_type.element_renderer)
+        self.write(">")
+
+    @serialize_use.register
+    def _(self, renderer_type: ContainerRenderer):
+        self.write_type_unique_id(renderer_type)

python/rlc/renderer/renderable.py

@@ -1,41 +1,74 @@
 
 from abc import ABC, abstractmethod
+from copy import deepcopy
 from rlc.layout import Layout, Direction, FIT, Padding
 from typing import Dict
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, fields, is_dataclass, MISSING
 from rlc.text import Text
+import yaml
 
 _renderer_registry = {}  # maps class name → class
 
+class RenderableDumper(yaml.SafeDumper):
+    index = 0
+    def generate_anchor(self, node: yaml.Node):
+
+        self.index = self.index + 1
+        return str(self.index)
+
+class RenderableLoader(yaml.FullLoader):
+    pass
+
+def renderable_representer(dumper: RenderableDumper, obj: 'Renderable'):
+    tag = obj.yaml_tag()
+    mapping = []
+    for f in fields(obj):
+        value = getattr(obj, f.name)
+
+        if f.default is not MISSING and value == f.default:
+            continue
+
+        if f.default_factory is not MISSING:
+            try:
+                default = f.default_factory()
+                if value == default:
+                    continue
+            except TypeError:
+                pass
+
+        mapping.append((f.name, value))
+    return dumper.represent_mapping(tag, mapping)
+
+
+def renderable_multi_constructor(loader: RenderableLoader, tag_suffix: str, node):
+    """
+    tag_suffix is the part after the '!' when using add_multi_constructor("!", ...)
+    e.g. YAML tag `!FooRenderer` → tag_suffix == "FooRenderer"
+    """
+    cls = _renderer_registry[tag_suffix]  # look up the class
+    data = loader.construct_mapping(node, deep=True)
+    return cls(**data)
+
+yaml.add_multi_constructor("!", renderable_multi_constructor, Loader=RenderableLoader)
+
 def register_renderer(cls):
     _renderer_registry[cls.__name__] = cls
     return cls
 
-@dataclass(kw_only=True)
+@dataclass
 class Renderable(ABC):
     """
     Base abstract renderer type.
     Each subclasss knows how to convert its types object into a Layout tree.
     """
-    rlc_type_name: str
-    style_policy: Dict = field(default_factory=dict)
 
     def make_layout(self, direction=Direction.COLUMN, color="white", sizing=(FIT(), FIT()), logger=None, padding=Padding(2,2,2,2), border=3, child_gap=5) -> Layout:
         layout = Layout(sizing=sizing, direction=direction, color=color, padding=padding, border=border, child_gap=child_gap)
 
-        for attr, value in self.style_policy.items():
-            if value is not None and hasattr(layout, attr):
-                setattr(layout, attr, value)
-
         return layout
 
     def make_text(self, txt, font_name, font_size, color) -> Text:
         text = Text(txt, font_name, font_size, color)
-
-        for attr, value in self.style_policy.items():
-            if value is not None and hasattr(text, attr):
-                setattr(text, attr, value)
-
         return text
 
     @abstractmethod
@@ -59,7 +92,6 @@ def __call__(self, obj, parent_binding=None, **kwds):
         # If build_layout didn't set binding, ensure we add it
         if layout.binding is None:
             layout.binding = {
-                "type": self.rlc_type_name,
                 "parent": parent_binding,
             }
         else:
@@ -78,7 +110,34 @@ def __call__(self, obj, parent_binding=None, **kwds):
 
         return layout
 
+    def post_order_types(self):
+        frontier = [self]
+        seen = set()
+        output = []
+        while len(frontier) != 0:
+            current = frontier.pop(0)
+            if id(current) in seen:
+                continue
+            output.append(current)
+            seen.add(id(current))
+            for child in current._iter_children():
+                frontier.append(child)
+        return [x for x in reversed(output)]
+
+
+    def to_yaml(self):
+        return yaml.dump(self.post_order_types(), Dumper=RenderableDumper, sort_keys=False)
+
+    @classmethod
+    def from_yaml(cls, yaml_text):
+        return yaml.load(yaml_text, Loader=RenderableLoader)[-1]
+
+    @classmethod
+    def yaml_tag(cls) -> str:
+        return f"!{cls.__name__}"
 
     def _iter_children(self):
         """Return iterable of child renderers, if any. Override per subclass."""
         return []
+
+yaml.add_multi_representer(Renderable, renderable_representer, Dumper=RenderableDumper)

python/rlc/renderer/struct_renderer.py

@@ -7,6 +7,7 @@
 @register_renderer
 @dataclass
 class ContainerRenderer(Renderable):
+    name: str
     field_renderers: List[Renderable]
 
     def build_layout(self, obj, direction=Direction.COLUMN, color="white", sizing=(FIT(), FIT()), logger=None, padding=Padding(7,7,7,7)):

python/rlc/renderer_type_conversion.py

@@ -9,56 +9,58 @@
 from rlc.renderer.bint_renderer import BoundedIntRenderer
 
 
-_renderer_cache = {}
 def create_renderer(rlc_type, config : Dict[type, type]):
-    if rlc_type in _renderer_cache:
-        return _renderer_cache[rlc_type]
+    _renderer_cache = {}
+    def _create_renderer(rlc_type, config : Dict[type, type]):
+        if rlc_type in _renderer_cache:
+            return _renderer_cache[rlc_type]
 
-    name = getattr(rlc_type, "__name__", str(rlc_type))
+        name = getattr(rlc_type, "__name__", str(rlc_type))
 
-    if rlc_type in config:
-        pytyp = config.get(rlc_type)
-        if hasattr(rlc_type, "_fields_"):
-            field_renderer = {
-                name: create_renderer(field_type, config) for name, field_type in rlc_type._fields_
-            }
-            renderer = pytyp(rlc_type, field_renderer)
-            return renderer
+        if rlc_type in config:
+            pytyp = config.get(rlc_type)
+            if hasattr(rlc_type, "_fields_"):
+                field_renderer = {
+                    name: _create_renderer(field_type, config) for name, field_type in rlc_type._fields_
+                }
+                renderer = pytyp(rlc_type, field_renderer)
+                return renderer
 
-    # Vector
-    elif "Vector" in name:
-        # find the _data field to determine element type
-        data_field = next((f for f in getattr(rlc_type, "_fields_", []) if f[0] == "_data"), None)
-        if data_field:
-            element_type = getattr(data_field[1], "_type_", None)
-            if element_type is None:
-                element_type = data_field[1]
-            element_renderer = create_renderer(element_type, config)
-            renderer = VectorRenderer(element_renderer, rlc_type_name=name)
-        else:
-            renderer = PrimitiveRenderer(rlc_type_name=name)
+        # Vector
+        elif "Vector" in name:
+            # find the _data field to determine element type
+            data_field = next((f for f in getattr(rlc_type, "_fields_", []) if f[0] == "_data"), None)
+            if data_field:
+                element_type = getattr(data_field[1], "_type_", None)
+                if element_type is None:
+                    element_type = data_field[1]
+                element_renderer = _create_renderer(element_type, config)
+                renderer = VectorRenderer(element_renderer)
+            else:
+                renderer = PrimitiveRenderer()
 
 
-    # Array
-    elif hasattr(rlc_type, "_length_") and hasattr(rlc_type, "_type_"):
-        element_rendere = create_renderer(rlc_type._type_, config)
-        renderer = ArrayRenderer(rlc_type._length_, element_rendere, rlc_type_name=name)
+        # Array
+        elif hasattr(rlc_type, "_length_") and hasattr(rlc_type, "_type_"):
+            element_rendere = _create_renderer(rlc_type._type_, config)
+            renderer = ArrayRenderer(rlc_type._length_, element_rendere)
 
-    # Primitive
-    elif rlc_type == c_bool or rlc_type == c_long:
-        renderer = PrimitiveRenderer(rlc_type_name=name)
+        # Primitive
+        elif rlc_type == c_bool or rlc_type == c_long:
+            renderer = PrimitiveRenderer()
 
-    # Bounded integer
-    elif name.startswith("BInt"):
-        renderer = BoundedIntRenderer(rlc_type_name=name)
+        # Bounded integer
+        elif name.startswith("BInt"):
+            renderer = BoundedIntRenderer()
 
-    # Struct
-    elif hasattr(rlc_type, "_fields_"):
-        field_renderer = {
-            name: create_renderer(field_type, config) for name, field_type in rlc_type._fields_
-        }
-        renderer = ContainerRenderer(field_renderer, rlc_type_name=name)
-    else:
-        renderer = PrimitiveRenderer(name)
-    _renderer_cache[rlc_type] = renderer
-    return renderer
+        # Struct
+        elif hasattr(rlc_type, "_fields_"):
+            field_renderer = {
+                name: _create_renderer(field_type, config) for name, field_type in rlc_type._fields_
+            }
+            renderer = ContainerRenderer(name, field_renderer)
+        else:
+            renderer = PrimitiveRenderer(name)
+        _renderer_cache[rlc_type] = renderer
+        return renderer
+    return _create_renderer(rlc_type, config)