#135: Initial work to Group Schedule Table Inputs

server/scripts/parse-template-package.ts

@@ -10,10 +10,13 @@ import {
 
 loadPackage("Buildings");
 
+const { options, scheduleOptions } = getOptions();
+
 const data = {
   templates: getTemplates(),
   systemTypes: getSystemTypes(),
-  options: getOptions(),
+  options: options,
+  scheduleOptions: scheduleOptions,
 };
 
 const dest = path.resolve(

server/scripts/parse-test-package.ts

@@ -13,10 +13,13 @@ loadPackage(`${fullTempDirPath}/TestPackage`);
 // const buildDir = `${process.cwd()}/build/modelica-json/json`;
 // loadPackage(`${buildDir}/Buildings/Templates`);
 
+const { options, scheduleOptions } = getOptions();
+
 const data = {
   templates: getTemplates(),
   systemTypes: getSystemTypes(),
-  options: getOptions(),
+  options: options,
+  scheduleOptions: scheduleOptions,
 };
 
 const dest = path.resolve(

server/src/parser/index.ts

@@ -28,6 +28,9 @@ export function getSystemTypes(): templates.SystemTypeN[] {
   return templates.getSystemTypes();
 }
 
-export function getOptions(): parser.OptionN[] {
+export function getOptions(): {
+  options: parser.OptionN[];
+  scheduleOptions: templates.ScheduleOption[];
+} {
   return templates.getOptions();
 }

server/src/parser/modification.ts

@@ -1,3 +1,5 @@
+import { ShortClassSpecifier } from "./parser";
+
 /**
  * Modifications are places where there is an assignment, e.g.
  * 'my_param=5'. Modifications can also contain groups of modifications, e.g.
@@ -23,22 +25,38 @@
 
 const modStore: Map<string, Modification> = new Map();
 
-type RedeclarationMod = {
+type ComponentDeclaration1 = {
+  declaration: DeclarationBlock;
+  description?: DescriptionBlock;
+};
+
+type ComponentClause1 = {
+  type_specifier: string; // Modelica Path
+  component_declaration1: ComponentDeclaration1;
+};
+
+type ShortClassDefinition = {
+  class_prefixes: string; // //(PARTIAL)? (CLASS | MODEL | (OPERATOR)? RECORD | BLOCK | (EXPANDABLE)? CONNECTOR | TYPE | PACKAGE | ((PURE | IMPURE))? (OPERATOR)? FUNCTION | OPERATOR),
+  short_class_specifier: ShortClassSpecifier; // from 'parser.ts'
+};
+
+type ElementReplaceable = {
+  component_clause1: ComponentClause1;
+  short_class_definition: ShortClassDefinition;
+};
+
+type RedeclareMod = {
   element_redeclaration: {
-    element_replaceable: {
-      component_clause1: {
-        type_specifier: string; // Modelica Path
-        component_declaration1: {
-          declaration: DeclarationBlock;
-          description: DescriptionBlock;
-        };
-      };
-    }
+    each: boolean;
+    final: boolean;
+    short_class_definition?: ShortClassDefinition;
+    element_replaceable?: ElementReplaceable;
+    component_clause1?: ComponentClause1;
   };
 };
 
 type ClassMod = {
-  class_modification: (WrappedMod | RedeclarationMod)[];
+  class_modification: (WrappedMod | RedeclareMod)[];
 };
 
 type Assignment = {
@@ -57,12 +75,12 @@ export type WrappedMod = {
 
 export type Mod = {
   name: string;
-  modification: ClassMod | WrappedMod | Assignment | RedeclarationMod;
+  modification: ClassMod | WrappedMod | Assignment | RedeclareMod;
 };
 
 export type DeclarationBlock = {
   identifier: string;
-  modification?: ClassMod | WrappedMod | Assignment | RedeclarationMod;
+  modification?: ClassMod | WrappedMod | Assignment | RedeclareMod;
 };
 
 export type DescriptionBlock = {
@@ -79,25 +97,28 @@ export function getModificationList(
   classMod: ClassMod,
   modelicaPath: string,
   name = "",
-): Modification[] {
-  return classMod.class_modification.map((m) =>
-    createModification({
-      definition: m as WrappedMod,
-      basePath: modelicaPath,
-      name: name,
-    }),
-  );
+) {
+  return classMod.class_modification
+    .map((m) =>
+      createModification({
+        definition: m as WrappedMod,
+        basePath: modelicaPath,
+        name: name,
+      }),
+    )
+    .filter((m) => m !== undefined) as Modification[];
 }
 
 interface ModificationBasics {
   basePath?: string;
   name?: string;
   value?: any;
   definition?: any;
+  type?: string;
 }
 
 interface ModificationWithDefinition extends ModificationBasics {
-  definition: WrappedMod | Mod | DeclarationBlock;
+  definition: WrappedMod | Mod | DeclarationBlock | RedeclareMod;
   value?: never;
 }
 
@@ -109,6 +130,64 @@ interface ModificationWithValue extends ModificationBasics {
 
 type ModificationProps = ModificationWithDefinition | ModificationWithValue;
 
+function unpackRedeclaration(props: ModificationProps) {
+  let { definition } = props;
+  const redeclaration = (definition as RedeclareMod).element_redeclaration;
+  if ("component_clause1" in redeclaration) {
+    const componentClause1 =
+      redeclaration.component_clause1 as ComponentClause1;
+    const type = componentClause1.type_specifier;
+    const redeclareDefinition =
+      componentClause1.component_declaration1.declaration;
+    const modProps = { ...props, type, definition: redeclareDefinition };
+    const redeclareMod = createModification(modProps);
+    return redeclareMod;
+  } else if ("short_class_definition" in redeclaration) {
+  } else if ("element_replaceable" in redeclaration) {
+  }
+}
+
+function unpackModblock(props: ModificationProps) {
+  let mods: Modification[] = [];
+  let value: string = "";
+  let { definition, basePath = "", name } = props as ModificationWithDefinition;
+
+  let modBlock = definition;
+
+  modBlock =
+    "element_modification_or_replaceable" in definition
+      ? definition.element_modification_or_replaceable.element_modification
+      : definition;
+
+  if ("name" in modBlock) {
+    name = modBlock.name;
+  } else if ("identifier" in modBlock) {
+    name = modBlock.identifier;
+  }
+
+  let modelicaPath = basePath ? `${basePath}.${name}` : "";
+  const mod = (modBlock as Mod).modification;
+  if (mod) {
+    // test if an assignment
+    if ("equal" in mod) {
+      // simple_expression can potentially be an expression
+      // TODO be ready to feed that into Expression generator
+      value = (mod as Assignment).expression.simple_expression;
+    } else if (name == "choice") {
+      const choiceMod = (mod as ClassMod).class_modification[0] as RedeclareMod;
+      if (choiceMod.element_redeclaration) {
+        const replaceable = choiceMod.element_redeclaration
+          .element_replaceable as ElementReplaceable;
+        value = replaceable.component_clause1.type_specifier;
+      }
+    } else if ("class_modification" in mod) {
+      mods = getModificationList(mod as ClassMod, modelicaPath);
+    }
+  }
+
+  return new Modification(basePath, name, value, mods);
+}
+
 /**
  * Factory method that can create a Modification from two approaches:
  *
@@ -118,40 +197,19 @@ type ModificationProps = ModificationWithDefinition | ModificationWithValue;
  * @param props: ModificationProps
  * @returns Modification
  */
-export function createModification(props: ModificationProps): Modification {
+export function createModification(
+  props: ModificationProps,
+): Modification | undefined {
   let mods: Modification[] = [];
   let { definition, value, basePath = "", name } = props;
   let modelicaPath = basePath ? `${basePath}.${name}` : "";
 
   if (definition) {
-    const modBlock =
-      "element_modification_or_replaceable" in definition
-        ? definition.element_modification_or_replaceable.element_modification
-        : definition;
-
-    if ("name" in modBlock) {
-      name = modBlock.name;
-    } else if ("identifier" in modBlock) {
-      name = modBlock.identifier;
+    if ("element_redeclaration" in definition) {
+      return unpackRedeclaration(props);
     }
 
-    const mod = modBlock.modification;
-    if (mod) {
-      // test if an assignment
-      if ("equal" in mod) {
-        // simple_expression can potentially be an expression
-        // TODO be ready to feed that into Expression generator
-        value = (mod as Assignment).expression.simple_expression;
-      } else if (name == "choice") {
-        const choiceMod = (mod as ClassMod)
-          .class_modification[0] as RedeclarationMod;
-        value =
-          choiceMod.element_redeclaration.element_replaceable.component_clause1.type_specifier;
-      } else if ("class_modification" in mod) {
-        // const type = "";
-        mods = getModificationList(mod as ClassMod, modelicaPath);
-      }
-    }
+    return unpackModblock(props);
   }
 
   return new Modification(basePath, name, value, mods);