devtools: refactor tree

Author: kobkaz

tmtc-c2a/devtools_frontend/src/components/TelemetryView.tsx

@@ -1,25 +1,20 @@
 import React, { useCallback, useEffect, useMemo, useState } from "react";
-import {
-  TreeBlueprintNamespace,
-  TreeNamespace,
-  buildTree,
-  digTreeBlueprintNamespace,
-} from "../tree";
+import { TreeNamespace, addToNamespace, mapNamespace } from "../tree";
 
 import { Tmiv, TmivField } from "../proto/tco_tmiv";
 import { useClient } from "./Layout";
 import { useParams } from "react-router-dom";
 import { Helmet } from "react-helmet-async";
 import { TelemetrySchema } from "../proto/tmtc_generic_c2a";
 
-const buildTelemetryFieldTreeBlueprintFromSchema = (tlm: TelemetrySchema) => {
+const buildTelemetryFieldTreeBlueprintFromSchema = (
+  tlm: TelemetrySchema,
+): TreeNamespace<undefined> => {
   const fieldNames = tlm.fields.map((f) => f.name);
-  const root: TreeBlueprintNamespace = new Map();
+  const root: TreeNamespace<undefined> = new Map();
   for (const fieldName of fieldNames) {
     const path = fieldName.split(".");
-    const basename = path.pop()!;
-    const ns = digTreeBlueprintNamespace(root, path);
-    ns.set(basename, { type: "leaf", key: fieldName });
+    addToNamespace(root, path, undefined);
   }
   return root;
 };
@@ -30,7 +25,7 @@ type TelemetryValuePair = {
 };
 
 const buildTelemetryFieldTree = (
-  blueprint: TreeBlueprintNamespace,
+  blueprint: TreeNamespace<undefined>,
   fields: TmivField[],
 ): TreeNamespace<TelemetryValuePair> => {
   const convertedFieldMap = new Map<string, TmivField["value"]>();
@@ -43,7 +38,8 @@ const buildTelemetryFieldTree = (
       convertedFieldMap.set(field.name, field.value);
     }
   }
-  return buildTree(blueprint, (key) => {
+  return mapNamespace(blueprint, (path, _key) => {
+    const key = path.join(".");
     const converted = convertedFieldMap.get(key) ?? null;
     const raw = rawFieldMap.get(key) ?? null;
     return { converted, raw };

tmtc-c2a/devtools_frontend/src/tree.ts

@@ -1,56 +1,109 @@
-export type TreeBlueprintNamespace = Map<string, TreeBlueprintNode>;
-export type TreeBlueprintNode =
-  | { type: "leaf"; key: string }
-  | { type: "ns"; ns: TreeBlueprintNamespace };
-export const digTreeBlueprintNamespace = (
-  ns: TreeBlueprintNamespace,
-  path: string[],
-): TreeBlueprintNamespace => {
-  if (path.length === 0) {
-    return ns;
-  }
-  const [pathHead, ...pathTail] = path;
-  const childNs = (() => {
-    if (ns.has(pathHead)) {
-      const node = ns.get(pathHead)!;
-      switch (node.type) {
-        case "ns":
-          return node.ns;
-        case "leaf": {
-          const childNs: TreeBlueprintNamespace = new Map();
-          childNs.set("", node);
-          ns.set(pathHead, { type: "ns", ns: childNs });
-          return childNs;
-        }
-      }
-    } else {
-      const childNs: TreeBlueprintNamespace = new Map();
-      ns.set(pathHead, { type: "ns", ns: childNs });
-      return childNs;
-    }
-  })();
-  return digTreeBlueprintNamespace(childNs, pathTail);
-};
-
 export type TreeNamespace<T> = Map<string, TreeNode<T>>;
 export type TreeNode<T> =
   | { type: "leaf"; value: T }
   | { type: "ns"; ns: TreeNamespace<T> };
 
-export const buildTree = <T>(
-  blueprint: TreeBlueprintNamespace,
-  getValue: (key: string) => T,
-): TreeNamespace<T> => {
-  const map = new Map();
-  for (const [key, value] of blueprint) {
-    switch (value.type) {
-      case "leaf":
-        map.set(key, { type: "leaf", value: getValue(value.key) });
-        break;
-      case "ns":
-        map.set(key, { type: "ns", ns: buildTree(value.ns, getValue) });
-        break;
+const makeLeaf = <T>(value: T): TreeNode<T> => ({ type: "leaf", value });
+const makeNs = <T>(ns: TreeNamespace<T>): TreeNode<T> => ({ type: "ns", ns });
+
+const mapMapWithKey = <K, T, U>(
+  map: Map<K, T>,
+  f: (key: K, value: T) => U,
+): Map<K, U> => {
+  const result = new Map();
+  for (const [key, value] of map) {
+    result.set(key, f(key, value));
+  }
+  return result;
+};
+
+const mapTreeRec = <T, U>(
+  tree: TreeNode<T>,
+  path: string[],
+  f: (path: string[], node: T) => U,
+): TreeNode<U> => {
+  switch (tree.type) {
+    case "leaf":
+      return makeLeaf(f(path, tree.value));
+    case "ns":
+      return makeNs(
+        mapMapWithKey(tree.ns, (key, child) =>
+          mapTreeRec(child, [...path, key], f),
+        ),
+      );
+  }
+};
+
+export const mapTree = <T, U>(
+  tree: TreeNode<T>,
+  f: (path: string[], node: T) => U,
+): TreeNode<U> => {
+  return mapTreeRec(tree, [], f);
+};
+
+export const mapNamespace = <T, U>(
+  ns: TreeNamespace<T>,
+  f: (path: string[], node: T) => U,
+): TreeNamespace<U> => {
+  const tree = makeNs(ns);
+  const mappedTree = mapTreeRec(tree, [], f);
+  if (mappedTree.type === "ns") {
+    return mappedTree.ns;
+  } else {
+    throw new Error("Impossible");
+  }
+};
+
+export const singleton = <T>(path: string[], value: T): TreeNode<T> => {
+  let tree: TreeNode<T> = { type: "leaf", value };
+  for (const key of path.toReversed()) {
+    const ns = new Map();
+    ns.set(key, tree);
+    tree = { type: "ns", ns };
+  }
+  return tree;
+};
+
+export const add = <T>(
+  tree: TreeNode<T>,
+  path: string[],
+  value: T,
+): TreeNode<T> => {
+  switch (tree.type) {
+    case "leaf":
+      if (path.length === 0) {
+        tree.value = value;
+        return tree;
+      } else {
+        const [pathHead, ...pathTail] = path;
+        const ns = new Map();
+        ns.set("", tree);
+        ns.set(pathHead, singleton(pathTail, value));
+        return {
+          type: "ns",
+          ns,
+        };
+      }
+    case "ns":
+      addToNamespace(tree.ns, path, value);
+      return tree;
+  }
+};
+
+export const addToNamespace = <T>(
+  ns: TreeNamespace<T>,
+  path: string[],
+  value: T,
+): void => {
+  if (path.length === 0) {
+    ns.set("", { type: "leaf", value });
+  } else {
+    const [pathHead, ...pathTail] = path;
+    const child = ns.get(pathHead);
+    if (child === undefined) {
+      ns.set(pathHead, singleton(pathTail, value));
+    } else {
+      ns.set(pathHead, add(child, pathTail, value));
     }
   }
-  return map;
 };