@hla4ts/fom-codegen 0.1.0

package/src/xml-writer.ts

@@ -0,0 +1,502 @@
+import type {
+  AttributeSchema,
+  DataTypeSchema,
+  DimensionSchema,
+  FomModel,
+  FomOutputOptions,
+  InteractionClassSchema,
+  ObjectClassSchema,
+  TransportationSchema,
+} from "./types.ts";
+
+const DEFAULT_NAMESPACE = "http://standards.ieee.org/IEEE1516-2025";
+const DEFAULT_SCHEMA_LOCATION_OMT =
+  "http://standards.ieee.org/IEEE1516-2025 IEEE1516-OMT-2025.xsd";
+const DEFAULT_SCHEMA_LOCATION_FDD =
+  "http://standards.ieee.org/IEEE1516-2025 IEEE1516-FDD-2025.xsd";
+
+const DEFAULT_TRANSPORTATIONS: TransportationSchema[] = [
+  { name: "HLAreliable", reliable: "Yes" },
+  { name: "HLAbestEffort", reliable: "No" },
+];
+
+export function renderFomXml(model: FomModel, options: FomOutputOptions): string {
+  const indent = options.indent ?? "  ";
+  const schemaLocation =
+    options.schemaLocation ??
+    (options.format === "omt" ? DEFAULT_SCHEMA_LOCATION_OMT : DEFAULT_SCHEMA_LOCATION_FDD);
+  const includeModelIdentification = options.includeModelIdentification ?? true;
+  const inferParentStubs = options.inferParentStubs ?? true;
+
+  const writer = new XmlWriter(indent);
+  writer.declaration();
+  writer.openTag("objectModel", {
+    xmlns: DEFAULT_NAMESPACE,
+    "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+    "xsi:schemaLocation": schemaLocation,
+  });
+
+  if (includeModelIdentification && model.modelIdentification) {
+    renderModelIdentification(writer, model.modelIdentification);
+  }
+
+  renderObjects(writer, model.objectClasses, inferParentStubs);
+  renderInteractions(writer, model.interactionClasses, inferParentStubs);
+  renderDimensions(writer, model.dimensions ?? []);
+  if (model.time) {
+    renderTime(writer, model.time);
+  }
+  renderTransportations(writer, model.transportations ?? DEFAULT_TRANSPORTATIONS);
+  if (model.switches) {
+    renderSwitches(writer, model.switches);
+  }
+  renderDataTypes(writer, model.dataTypes);
+
+  writer.closeTag("objectModel");
+  return writer.toString();
+}
+
+function renderModelIdentification(writer: XmlWriter, model: FomModel["modelIdentification"]) {
+  if (!model) return;
+  writer.openTag("modelIdentification");
+  writer.element("name", model.name);
+  writer.element("type", model.type);
+  writer.element("version", model.version);
+  writer.element("modificationDate", model.modificationDate);
+  writer.element("securityClassification", model.securityClassification);
+  if (model.purpose) writer.element("purpose", model.purpose);
+  if (model.applicationDomain) writer.element("applicationDomain", model.applicationDomain);
+  writer.element("description", model.description);
+  if (model.useLimitation) writer.element("useLimitation", model.useLimitation);
+  if (model.keyword) {
+    for (const keyword of model.keyword) {
+      writer.openTag("keyword");
+      if (keyword.taxonomy) writer.element("taxonomy", keyword.taxonomy);
+      writer.element("keywordValue", keyword.keywordValue);
+      writer.closeTag("keyword");
+    }
+  }
+  writer.closeTag("modelIdentification");
+}
+
+function renderTime(writer: XmlWriter, time: FomModel["time"]) {
+  if (!time) return;
+  writer.openTag("time");
+  writer.openTag("timeStamp");
+  writer.element("dataType", time.timeStampType);
+  if (time.semantics?.timeStamp) {
+    writer.element("semantics", time.semantics.timeStamp);
+  }
+  writer.closeTag("timeStamp");
+  writer.openTag("lookahead");
+  writer.element("dataType", time.lookaheadType);
+  if (time.semantics?.lookahead) {
+    writer.element("semantics", time.semantics.lookahead);
+  }
+  writer.closeTag("lookahead");
+  writer.closeTag("time");
+}
+
+type ObjectNode = {
+  fullName: string;
+  name: string;
+  schema?: ObjectClassSchema;
+  __children?: ObjectNode[];
+};
+type InteractionNode = {
+  fullName: string;
+  name: string;
+  schema?: InteractionClassSchema;
+  __children?: InteractionNode[];
+};
+
+function renderObjects(writer: XmlWriter, classes: ObjectClassSchema[], inferParentStubs: boolean) {
+  writer.openTag("objects");
+  const roots = buildHierarchy<ObjectClassSchema, ObjectNode>(classes, "HLAobjectRoot", inferParentStubs);
+  const root =
+    roots.root ??
+    createNode<ObjectClassSchema, ObjectNode>("HLAobjectRoot", "HLAobjectRoot");
+  renderObjectClass(writer, root);
+  writer.closeTag("objects");
+}
+
+function renderObjectClass(writer: XmlWriter, node: ObjectNode) {
+  const obj = node.schema;
+  writer.openTag("objectClass");
+  writer.element("name", node.name);
+  if (obj?.sharing) writer.element("sharing", obj.sharing);
+  if (obj?.semantics) writer.element("semantics", obj.semantics);
+  if (obj?.attributes) {
+    for (const attr of obj.attributes) {
+      renderAttribute(writer, attr);
+    }
+  }
+  for (const child of node.__children ?? []) {
+    renderObjectClass(writer, child);
+  }
+  writer.closeTag("objectClass");
+}
+
+function renderAttribute(writer: XmlWriter, attr: AttributeSchema) {
+  writer.openTag("attribute");
+  writer.element("name", attr.name);
+  writer.element("dataType", attr.dataType);
+  writer.element("updateType", attr.updateType);
+  writer.element("updateCondition", attr.updateCondition);
+  writer.element("ownership", attr.ownership);
+  writer.element("sharing", attr.sharing);
+  writer.element("transportation", attr.transportation);
+  writer.element("order", attr.order);
+  if (attr.valueRequired !== undefined) {
+    writer.element("valueRequired", attr.valueRequired ? "true" : "false");
+  }
+  if (attr.semantics) writer.element("semantics", attr.semantics);
+  writer.closeTag("attribute");
+}
+
+function renderInteractions(
+  writer: XmlWriter,
+  classes: InteractionClassSchema[],
+  inferParentStubs: boolean
+) {
+  writer.openTag("interactions");
+  const roots = buildHierarchy<InteractionClassSchema, InteractionNode>(
+    classes,
+    "HLAinteractionRoot",
+    inferParentStubs
+  );
+  const root =
+    roots.root ??
+    createNode<InteractionClassSchema, InteractionNode>(
+      "HLAinteractionRoot",
+      "HLAinteractionRoot"
+    );
+  renderInteractionClass(writer, root);
+  writer.closeTag("interactions");
+}
+
+function renderInteractionClass(writer: XmlWriter, node: InteractionNode) {
+  const interaction = node.schema;
+  writer.openTag("interactionClass");
+  writer.element("name", node.name);
+  if (interaction?.sharing) writer.element("sharing", interaction.sharing);
+  if (interaction?.transportation) writer.element("transportation", interaction.transportation);
+  if (interaction?.order) writer.element("order", interaction.order);
+  if (interaction?.semantics) writer.element("semantics", interaction.semantics);
+  if (interaction?.parameters) {
+    for (const param of interaction.parameters) {
+      writer.openTag("parameter");
+      writer.element("name", param.name);
+      writer.element("dataType", param.dataType);
+      if (param.semantics) writer.element("semantics", param.semantics);
+      writer.closeTag("parameter");
+    }
+  }
+  for (const child of node.__children ?? []) {
+    renderInteractionClass(writer, child);
+  }
+  writer.closeTag("interactionClass");
+}
+
+function renderDimensions(writer: XmlWriter, dimensions: DimensionSchema[]) {
+  writer.openTag("dimensions");
+  for (const dim of dimensions) {
+    writer.openTag("dimension");
+    writer.element("name", dim.name);
+    if (dim.dataType) writer.element("dataType", dim.dataType);
+    writer.closeTag("dimension");
+  }
+  writer.closeTag("dimensions");
+}
+
+function renderTransportations(writer: XmlWriter, transportations: TransportationSchema[]) {
+  writer.openTag("transportations");
+  for (const transport of transportations) {
+    writer.openTag("transportation");
+    writer.element("name", transport.name);
+    if (transport.reliable) {
+      writer.element("reliable", transport.reliable);
+    }
+    writer.closeTag("transportation");
+  }
+  writer.closeTag("transportations");
+}
+
+function renderSwitches(writer: XmlWriter, switches: FomModel["switches"]) {
+  if (!switches) return;
+  writer.openTag("switches");
+  writer.emptyTag("autoProvide", { isEnabled: switches.autoProvide ? "true" : "false" });
+  writer.emptyTag("conveyRegionDesignatorSets", { isEnabled: switches.conveyRegionDesignatorSets ? "true" : "false" });
+  writer.emptyTag("conveyProducingFederate", { isEnabled: switches.conveyProducingFederate ? "true" : "false" });
+  writer.emptyTag("attributeScopeAdvisory", { isEnabled: switches.attributeScopeAdvisory ? "true" : "false" });
+  writer.emptyTag("attributeRelevanceAdvisory", { isEnabled: switches.attributeRelevanceAdvisory ? "true" : "false" });
+  writer.emptyTag("objectClassRelevanceAdvisory", { isEnabled: switches.objectClassRelevanceAdvisory ? "true" : "false" });
+  writer.emptyTag("interactionRelevanceAdvisory", { isEnabled: switches.interactionRelevanceAdvisory ? "true" : "false" });
+  writer.emptyTag("serviceReporting", { isEnabled: switches.serviceReporting ? "true" : "false" });
+  writer.emptyTag("exceptionReporting", { isEnabled: switches.exceptionReporting ? "true" : "false" });
+  writer.emptyTag("delaySubscriptionEvaluation", { isEnabled: switches.delaySubscriptionEvaluation ? "true" : "false" });
+  if (switches.automaticResignAction) {
+    writer.emptyTag("automaticResignAction", { resignAction: switches.automaticResignAction });
+  }
+  writer.closeTag("switches");
+}
+
+function renderDataTypes(writer: XmlWriter, dataTypes: DataTypeSchema[]) {
+  writer.openTag("dataTypes");
+  writer.openTag("simpleDataTypes");
+  for (const dt of dataTypes.filter((d) => d.kind === "simple")) {
+    writer.openTag("simpleData");
+    writer.element("name", dt.name);
+    writer.element("representation", dt.representation);
+    if (dt.units) writer.element("units", dt.units);
+    if (dt.resolution) writer.element("resolution", dt.resolution);
+    if (dt.accuracy) writer.element("accuracy", dt.accuracy);
+    if (dt.semantics) writer.element("semantics", dt.semantics);
+    writer.closeTag("simpleData");
+  }
+  writer.closeTag("simpleDataTypes");
+
+  writer.openTag("enumeratedDataTypes");
+  for (const dt of dataTypes.filter((d) => d.kind === "enumerated")) {
+    writer.openTag("enumeratedData");
+    writer.element("name", dt.name);
+    writer.element("representation", dt.representation);
+    if (dt.semantics) writer.element("semantics", dt.semantics);
+    for (const enumerator of dt.enumerators) {
+      writer.openTag("enumerator");
+      writer.element("name", enumerator.name);
+      const values = Array.isArray(enumerator.value) ? enumerator.value : [enumerator.value];
+      for (const value of values) {
+        writer.element("value", value);
+      }
+      writer.closeTag("enumerator");
+    }
+    writer.closeTag("enumeratedData");
+  }
+  writer.closeTag("enumeratedDataTypes");
+
+  writer.openTag("arrayDataTypes");
+  for (const dt of dataTypes.filter((d) => d.kind === "array")) {
+    writer.openTag("arrayData");
+    writer.element("name", dt.name);
+    writer.element("dataType", dt.dataType);
+    writer.element("cardinality", dt.cardinality);
+    writer.element("encoding", dt.encoding);
+    if (dt.semantics) writer.element("semantics", dt.semantics);
+    writer.closeTag("arrayData");
+  }
+  writer.closeTag("arrayDataTypes");
+
+  writer.openTag("fixedRecordDataTypes");
+  for (const dt of dataTypes.filter((d) => d.kind === "fixedRecord")) {
+    writer.openTag("fixedRecordData");
+    writer.element("name", dt.name);
+    writer.element("encoding", dt.encoding);
+    if (dt.semantics) writer.element("semantics", dt.semantics);
+    for (const field of dt.fields) {
+      writer.openTag("field");
+      writer.element("name", field.name);
+      writer.element("dataType", field.dataType);
+      if (field.semantics) writer.element("semantics", field.semantics);
+      writer.closeTag("field");
+    }
+    writer.closeTag("fixedRecordData");
+  }
+  writer.closeTag("fixedRecordDataTypes");
+
+  writer.openTag("variantRecordDataTypes");
+  for (const dt of dataTypes.filter((d) => d.kind === "variantRecord")) {
+    writer.openTag("variantRecordData");
+    writer.element("name", dt.name);
+    writer.element("discriminant", dt.discriminant);
+    writer.element("dataType", dt.dataType);
+    for (const alt of dt.alternatives) {
+      writer.openTag("alternative");
+      writer.element("enumerator", alt.enumerator);
+      if (alt.name) writer.element("name", alt.name);
+      if (alt.dataType) writer.element("dataType", alt.dataType);
+      if (alt.semantics) writer.element("semantics", alt.semantics);
+      writer.closeTag("alternative");
+    }
+    writer.element("encoding", dt.encoding);
+    if (dt.semantics) writer.element("semantics", dt.semantics);
+    writer.closeTag("variantRecordData");
+  }
+  writer.closeTag("variantRecordDataTypes");
+
+  writer.closeTag("dataTypes");
+}
+
+function buildHierarchy<
+  T extends { name: string; parent?: string },
+  N extends { fullName: string; name: string; schema?: T; __children?: N[] }
+>(
+  classes: T[],
+  rootName: string,
+  inferParentStubs: boolean
+): { root: N | undefined; children: N[] } {
+  const map = new Map<string, N>();
+
+  for (const cls of classes) {
+    const fullName = resolveFullName(cls.name, cls.parent, rootName);
+    const node = map.get(fullName) ?? createNode<T, N>(fullName, localName(fullName));
+    node.schema = cls as T;
+    map.set(fullName, node);
+  }
+
+  if (inferParentStubs) {
+    for (const node of map.values()) {
+      ensureParentChain(map, node.fullName, rootName);
+    }
+  }
+
+  let root: N | undefined = map.get(rootName);
+  const orphans: N[] = [];
+
+  for (const node of map.values()) {
+    if (node.fullName === rootName) continue;
+    const parentFullName = resolveParentFullName(
+      node.fullName,
+      node.schema?.parent,
+      rootName
+    ) ?? rootName;
+    const parent = map.get(parentFullName);
+    if (parent) {
+      parent.__children?.push(node);
+    } else if (!inferParentStubs || parentFullName === rootName) {
+      orphans.push(node);
+    }
+  }
+
+  if (root) {
+    root.__children?.push(...orphans);
+  }
+
+  return {
+    root,
+    children: root ? root.__children ?? [] : orphans,
+  };
+}
+
+function createNode<
+  T extends { name: string; parent?: string },
+  N extends { fullName: string; name: string; schema?: T; __children?: N[] }
+>(fullName: string, name: string, schema?: T): N {
+  return { fullName, name, schema, __children: [] } as unknown as N;
+}
+
+function ensureParentChain<
+  T extends { name: string; parent?: string },
+  N extends { fullName: string; name: string; schema?: T; __children?: N[] }
+>(map: Map<string, N>, fullName: string, rootName: string): void {
+  let current = fullName;
+  while (true) {
+    const parent = inferParentFromFullName(current);
+    if (!parent) return;
+    if (!map.has(parent)) {
+      map.set(parent, createNode<T, N>(parent, localName(parent)));
+    }
+    if (parent === rootName) return;
+    current = parent;
+  }
+}
+
+function resolveFullName(name: string, parent: string | undefined, rootName: string): string {
+  if (name.includes(".")) return name;
+  if (name === rootName) return rootName;
+  const parentFull = resolveParentNameForFull(parent, rootName);
+  if (parentFull) return `${parentFull}.${name}`;
+  return `${rootName}.${name}`;
+}
+
+function resolveParentFullName(
+  fullName: string,
+  parent: string | undefined,
+  rootName: string
+): string | undefined {
+  if (parent) {
+    if (parent.includes(".")) return parent;
+    if (parent === rootName) return rootName;
+    return `${rootName}.${parent}`;
+  }
+  return inferParentFromFullName(fullName);
+}
+
+function inferParentFromFullName(fullName: string): string | undefined {
+  if (!fullName.includes(".")) return undefined;
+  const parent = fullName.slice(0, fullName.lastIndexOf("."));
+  if (!parent || parent === fullName) return undefined;
+  return parent;
+}
+
+function localName(fullName: string): string {
+  if (!fullName.includes(".")) return fullName;
+  return fullName.slice(fullName.lastIndexOf(".") + 1);
+}
+
+function resolveParentNameForFull(
+  parent: string | undefined,
+  rootName: string
+): string | undefined {
+  if (!parent) return undefined;
+  if (parent.includes(".")) return parent;
+  if (parent === rootName) return rootName;
+  return `${rootName}.${parent}`;
+}
+
+class XmlWriter {
+  private readonly _lines: string[] = [];
+  private readonly _indent: string;
+  private _level = 0;
+
+  constructor(indent: string) {
+    this._indent = indent;
+  }
+
+  declaration(): void {
+    this._lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  }
+
+  openTag(name: string, attrs?: Record<string, string>): void {
+    const attrText = attrs ? renderAttributes(attrs) : "";
+    this._lines.push(`${this._indent.repeat(this._level)}<${name}${attrText}>`);
+    this._level += 1;
+  }
+
+  closeTag(name: string): void {
+    this._level -= 1;
+    this._lines.push(`${this._indent.repeat(this._level)}</${name}>`);
+  }
+
+  element(name: string, content: string): void {
+    this._lines.push(
+      `${this._indent.repeat(this._level)}<${name}>${escapeXml(content)}</${name}>`
+    );
+  }
+
+  emptyTag(name: string, attrs?: Record<string, string>): void {
+    const attrText = attrs ? renderAttributes(attrs) : "";
+    this._lines.push(`${this._indent.repeat(this._level)}<${name}${attrText}/>`);
+  }
+
+  toString(): string {
+    return `${this._lines.join("\n")}\n`;
+  }
+}
+
+function renderAttributes(attrs: Record<string, string>): string {
+  const parts: string[] = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    parts.push(`${key}="${escapeXml(value)}"`);
+  }
+  return parts.length ? ` ${parts.join(" ")}` : "";
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}