@hla4ts/fom-codegen 0.1.0

package/src/xml-parser.ts

@@ -0,0 +1,359 @@
+import type {
+  AttributeSchema,
+  DataTypeSchema,
+  DimensionSchema,
+  FomModel,
+  InteractionClassSchema,
+  ModelIdentification,
+  ObjectClassSchema,
+  TransportationSchema,
+} from "./types.ts";
+
+type XmlElement = {
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlElement[];
+  text: string;
+};
+
+export function parseFomXml(xml: string): FomModel {
+  const root = parseXml(xml);
+
+  const modelIdentification = parseModelIdentification(findChild(root, "modelIdentification"));
+  const time = parseTime(findChild(root, "time"));
+  const objectClasses = parseObjectClasses(findChild(root, "objects"));
+  const interactionClasses = parseInteractionClasses(findChild(root, "interactions"));
+  const dataTypes = parseDataTypes(findChild(root, "dataTypes"));
+  const dimensions = parseDimensions(findChild(root, "dimensions"));
+  const transportations = parseTransportations(findChild(root, "transportations"));
+  const switches = parseSwitches(findChild(root, "switches"));
+
+  return {
+    modelIdentification,
+    time,
+    objectClasses,
+    interactionClasses,
+    dataTypes,
+    dimensions,
+    transportations,
+    switches,
+  };
+}
+
+function parseModelIdentification(node?: XmlElement): ModelIdentification | undefined {
+  if (!node) return undefined;
+  return {
+    name: childText(node, "name"),
+    type: childText(node, "type") as ModelIdentification["type"],
+    version: childText(node, "version"),
+    modificationDate: childText(node, "modificationDate"),
+    securityClassification: childText(node, "securityClassification"),
+    description: childText(node, "description"),
+    purpose: optional(childText(node, "purpose")),
+    applicationDomain: optional(childText(node, "applicationDomain")),
+    useLimitation: optional(childText(node, "useLimitation")),
+    keyword: getChildren(node, "keyword").map((kw) => ({
+      taxonomy: optional(childText(kw, "taxonomy")),
+      keywordValue: childText(kw, "keywordValue"),
+    })),
+  };
+}
+
+function parseTime(node?: XmlElement): FomModel["time"] | undefined {
+  if (!node) return undefined;
+  const timeStamp = findChild(node, "timeStamp");
+  const lookahead = findChild(node, "lookahead");
+  if (!timeStamp || !lookahead) return undefined;
+  return {
+    timeStampType: childText(timeStamp, "dataType"),
+    lookaheadType: childText(lookahead, "dataType"),
+    semantics: {
+      timeStamp: optional(childText(timeStamp, "semantics")),
+      lookahead: optional(childText(lookahead, "semantics")),
+    },
+  };
+}
+
+function parseObjectClasses(node?: XmlElement): ObjectClassSchema[] {
+  const root = node ? findChild(node, "objectClass") : undefined;
+  if (!root) return [];
+  return flattenObjectClasses(root, undefined);
+}
+
+function flattenObjectClasses(node: XmlElement, parent?: string): ObjectClassSchema[] {
+  const name = childText(node, "name");
+  const obj: ObjectClassSchema = {
+    name,
+    parent,
+    sharing: optional(childText(node, "sharing")) as ObjectClassSchema["sharing"],
+    semantics: optional(childText(node, "semantics")),
+    attributes: getChildren(node, "attribute").map(parseAttribute),
+  };
+  const children = getChildren(node, "objectClass").flatMap((child) =>
+    flattenObjectClasses(child, name)
+  );
+  return [obj, ...children];
+}
+
+function parseAttribute(node: XmlElement): AttributeSchema {
+  return {
+    name: childText(node, "name"),
+    dataType: childText(node, "dataType"),
+    updateType: (optional(childText(node, "updateType")) ?? "NA") as AttributeSchema["updateType"],
+    updateCondition: optional(childText(node, "updateCondition")) ?? "NA",
+    ownership: (optional(childText(node, "ownership")) ?? "NoTransfer") as AttributeSchema["ownership"],
+    sharing: (optional(childText(node, "sharing")) ?? "PublishSubscribe") as AttributeSchema["sharing"],
+    transportation: optional(childText(node, "transportation")) ?? "HLAreliable",
+    order: (optional(childText(node, "order")) ?? "Receive") as AttributeSchema["order"],
+    semantics: optional(childText(node, "semantics")),
+    valueRequired: parseBoolean(childText(node, "valueRequired")),
+  };
+}
+
+function parseInteractionClasses(node?: XmlElement): InteractionClassSchema[] {
+  const root = node ? findChild(node, "interactionClass") : undefined;
+  if (!root) return [];
+  return flattenInteractionClasses(root, undefined);
+}
+
+function flattenInteractionClasses(node: XmlElement, parent?: string): InteractionClassSchema[] {
+  const name = childText(node, "name");
+  const interaction: InteractionClassSchema = {
+    name,
+    parent,
+    sharing: optional(childText(node, "sharing")) as InteractionClassSchema["sharing"],
+    transportation: optional(childText(node, "transportation")),
+    order: optional(childText(node, "order")) as InteractionClassSchema["order"],
+    semantics: optional(childText(node, "semantics")),
+    parameters: getChildren(node, "parameter").map((param) => ({
+      name: childText(param, "name"),
+      dataType: childText(param, "dataType"),
+      semantics: optional(childText(param, "semantics")),
+    })),
+  };
+  const children = getChildren(node, "interactionClass").flatMap((child) =>
+    flattenInteractionClasses(child, name)
+  );
+  return [interaction, ...children];
+}
+
+function parseDataTypes(node?: XmlElement): DataTypeSchema[] {
+  if (!node) return [];
+  const dataTypes: DataTypeSchema[] = [];
+
+  const simpleDataTypes = findChild(node, "simpleDataTypes");
+  for (const simple of simpleDataTypes ? getChildren(simpleDataTypes, "simpleData") : []) {
+    dataTypes.push({
+      kind: "simple",
+      name: childText(simple, "name"),
+      representation: childText(simple, "representation"),
+      units: optional(childText(simple, "units")),
+      resolution: optional(childText(simple, "resolution")),
+      accuracy: optional(childText(simple, "accuracy")),
+      semantics: optional(childText(simple, "semantics")),
+    });
+  }
+
+  const enumeratedDataTypes = findChild(node, "enumeratedDataTypes");
+  for (const enumerated of enumeratedDataTypes ? getChildren(enumeratedDataTypes, "enumeratedData") : []) {
+    dataTypes.push({
+      kind: "enumerated",
+      name: childText(enumerated, "name"),
+      representation: childText(enumerated, "representation"),
+      semantics: optional(childText(enumerated, "semantics")),
+      enumerators: getChildren(enumerated, "enumerator").map((enumNode) => ({
+        name: childText(enumNode, "name"),
+        value: getChildren(enumNode, "value").map((valueNode) => textValue(valueNode)),
+      })),
+    });
+  }
+
+  const arrayDataTypes = findChild(node, "arrayDataTypes");
+  for (const array of arrayDataTypes ? getChildren(arrayDataTypes, "arrayData") : []) {
+    dataTypes.push({
+      kind: "array",
+      name: childText(array, "name"),
+      dataType: childText(array, "dataType"),
+      cardinality: childText(array, "cardinality"),
+      encoding: childText(array, "encoding"),
+      semantics: optional(childText(array, "semantics")),
+    });
+  }
+
+  const fixedRecordDataTypes = findChild(node, "fixedRecordDataTypes");
+  for (const record of fixedRecordDataTypes ? getChildren(fixedRecordDataTypes, "fixedRecordData") : []) {
+    dataTypes.push({
+      kind: "fixedRecord",
+      name: childText(record, "name"),
+      encoding: childText(record, "encoding"),
+      semantics: optional(childText(record, "semantics")),
+      fields: getChildren(record, "field").map((field) => ({
+        name: childText(field, "name"),
+        dataType: childText(field, "dataType"),
+        semantics: optional(childText(field, "semantics")),
+      })),
+    });
+  }
+
+  const variantRecordDataTypes = findChild(node, "variantRecordDataTypes");
+  for (const variant of variantRecordDataTypes ? getChildren(variantRecordDataTypes, "variantRecordData") : []) {
+    dataTypes.push({
+      kind: "variantRecord",
+      name: childText(variant, "name"),
+      discriminant: childText(variant, "discriminant"),
+      dataType: childText(variant, "dataType"),
+      encoding: childText(variant, "encoding"),
+      semantics: optional(childText(variant, "semantics")),
+      alternatives: getChildren(variant, "alternative").map((alt) => ({
+        enumerator: childText(alt, "enumerator"),
+        name: optional(childText(alt, "name")),
+        dataType: optional(childText(alt, "dataType")),
+        semantics: optional(childText(alt, "semantics")),
+      })),
+    });
+  }
+
+  return dataTypes;
+}
+
+function parseDimensions(node?: XmlElement): DimensionSchema[] {
+  if (!node) return [];
+  return getChildren(node, "dimension").map((dim) => ({
+    name: childText(dim, "name"),
+    dataType: optional(childText(dim, "dataType")),
+  }));
+}
+
+function parseTransportations(node?: XmlElement): TransportationSchema[] {
+  if (!node) return [];
+  return getChildren(node, "transportation").map((transport) => ({
+    name: childText(transport, "name"),
+    reliable: optional(childText(transport, "reliable")) as TransportationSchema["reliable"],
+  }));
+}
+
+function parseSwitches(node?: XmlElement): FomModel["switches"] | undefined {
+  if (!node) return undefined;
+  const readSwitch = (name: string): boolean => {
+    const element = findChild(node, name);
+    return parseBoolean(element?.attributes["isEnabled"]) ?? false;
+  };
+
+  const automaticResign = findChild(node, "automaticResignAction");
+
+  return {
+    autoProvide: readSwitch("autoProvide"),
+    conveyRegionDesignatorSets: readSwitch("conveyRegionDesignatorSets"),
+    conveyProducingFederate: readSwitch("conveyProducingFederate"),
+    attributeScopeAdvisory: readSwitch("attributeScopeAdvisory"),
+    attributeRelevanceAdvisory: readSwitch("attributeRelevanceAdvisory"),
+    objectClassRelevanceAdvisory: readSwitch("objectClassRelevanceAdvisory"),
+    interactionRelevanceAdvisory: readSwitch("interactionRelevanceAdvisory"),
+    serviceReporting: readSwitch("serviceReporting"),
+    exceptionReporting: readSwitch("exceptionReporting"),
+    delaySubscriptionEvaluation: readSwitch("delaySubscriptionEvaluation"),
+    automaticResignAction: automaticResign?.attributes["resignAction"],
+  };
+}
+
+function findChild(parent: XmlElement, name: string): XmlElement | undefined {
+  for (const child of parent.children) {
+    if (child.name === name) {
+      return child;
+    }
+  }
+  return undefined;
+}
+
+function getChildren(parent: XmlElement, name: string): XmlElement[] {
+  const result: XmlElement[] = [];
+  for (const child of parent.children) {
+    if (child.name === name) {
+      result.push(child);
+    }
+  }
+  return result;
+}
+
+function childText(parent: XmlElement, name: string): string {
+  const child = findChild(parent, name);
+  return child ? textValue(child) : "";
+}
+
+function textValue(node: XmlElement): string {
+  return node.text.trim();
+}
+
+function optional(value: string): string | undefined {
+  return value ? value : undefined;
+}
+
+function parseBoolean(value: string | null | undefined): boolean | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  return value.toLowerCase() === "true";
+}
+
+function parseXml(xml: string): XmlElement {
+  const cleaned = xml
+    .replace(/<\?xml[^>]*\?>/g, "")
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .trim();
+  const tokens = cleaned.match(/<[^>]+>|[^<]+/g) ?? [];
+  const stack: XmlElement[] = [];
+  let root: XmlElement | undefined;
+
+  for (const token of tokens) {
+    if (token.startsWith("<")) {
+      if (token.startsWith("</")) {
+        stack.pop();
+        continue;
+      }
+
+      const selfClosing = token.endsWith("/>");
+      const tagBody = token.slice(1, token.length - (selfClosing ? 2 : 1)).trim();
+      const [rawName, ...attrParts] = tagBody.split(/\s+/);
+      const name = stripNamespace(rawName);
+      const attributes = parseAttributes(attrParts.join(" "));
+      const element: XmlElement = { name, attributes, children: [], text: "" };
+
+      if (!root) {
+        root = element;
+      }
+      if (stack.length > 0) {
+        stack[stack.length - 1].children.push(element);
+      }
+      if (!selfClosing) {
+        stack.push(element);
+      }
+    } else if (stack.length > 0) {
+      const text = token.trim();
+      if (text) {
+        stack[stack.length - 1].text += text;
+      }
+    }
+  }
+
+  if (!root) {
+    throw new Error("Failed to parse XML: no root element found.");
+  }
+  return root;
+}
+
+function parseAttributes(text: string): Record<string, string> {
+  const attrs: Record<string, string> = {};
+  const regex = /([^\s=]+)\s*=\s*"(.*?)"|([^\s=]+)\s*=\s*'(.*?)'/g;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(text)) !== null) {
+    const name = stripNamespace(match[1] ?? match[3] ?? "");
+    const value = match[2] ?? match[4] ?? "";
+    if (name) {
+      attrs[name] = value;
+    }
+  }
+  return attrs;
+}
+
+function stripNamespace(name: string): string {
+  const parts = name.split(":");
+  return parts[parts.length - 1];
+}