jspurefix 3.5.0 → 4.0.0

package/src/dictionary/contained/contained-field-set.ts

@@ -1,27 +1,23 @@
 import { INumericKeyed } from '../../collections/collection'
-import { Dictionary } from '../../collections'
-import { ContainedComponentField } from './contained-component-field'
 import { ContainedField } from './contained-field'
-import { ContainedGroupField } from './contained-group-field'
 import { ContainedSimpleField } from './contained-simple-field'
 import { ElasticBuffer } from '../../buffer/elastic-buffer'
-import { ContainedFieldType } from './contained-field-type'
-import { TagType } from '../../buffer/tag/tag-type'
 import { ContainedSetType } from '../contained-set-type'
+import { IContainedSet } from './contained-set'
 
-export abstract class ContainedFieldSet {
+export abstract class ContainedFieldSet implements IContainedSet {
   /**
    * index of name to any group that may be present within the field list
    */
-  public readonly groups: Dictionary<ContainedGroupField> = new Dictionary<ContainedGroupField>()
+  public readonly groups: Map<string, IContainedSet> = new Map<string, IContainedSet>()
   /**
    * index of name to any component that may be present within the field list
    */
-  public readonly components: Dictionary<ContainedComponentField> = new Dictionary<ContainedComponentField>()
+  public readonly components: Map<string, IContainedSet> = new Map<string, IContainedSet>()
   /**
    * index of name to any simple field that may be present within the field list
    */
-  public readonly simple: Dictionary<ContainedSimpleField> = new Dictionary<ContainedSimpleField>()
+  public readonly simple: Map<string, ContainedSimpleField> = new Map<string, ContainedSimpleField>()
   /**
    *  sequence of fields representing this type - can be simple, group or component
    */
@@ -57,11 +53,11 @@ export abstract class ContainedFieldSet {
   /**
    * only repository directly in this set indexed by name
    */
-  public readonly localNameToField: Dictionary<ContainedField> = new Dictionary<ContainedField>()
+  public readonly localNameToField: Map<string, ContainedField> = new Map<string, ContainedField>()
   /**
    * for FixMl notation this set of fields appear as attributes i.e. <Pty ID="323" R="38">
    */
-  public readonly nameToLocalAttribute: Dictionary<ContainedSimpleField> = new Dictionary<ContainedSimpleField>()
+  public readonly nameToLocalAttribute: Map<string, ContainedSimpleField> = new Map<string, ContainedSimpleField>()
   /**
    * all attributes in order of being declared
    */
@@ -114,187 +110,36 @@ export abstract class ContainedFieldSet {
 
   public abstract getPrefix (): string
 
+  public keys (): number[] {
+    const keys: string[] = Object.keys(this.containedTag)
+    const nums: number[] = new Array(keys.length)
+    for (let j: number = 0; j < keys.length; ++j) {
+      nums[j] = parseInt(keys[j], 10)
+    }
+    return nums
+  }
+
   public getFieldName (tag: number): string {
     const s = this.tagToSimple[tag]
     if (s == null) {
-      const gf = this.tagToField[tag] as ContainedGroupField
+      const gf: ContainedField = this.tagToField[tag]
       if (gf !== null) {
-        return `${gf.definition.name}`
+        return `${gf.name}`
       }
       return `${tag}`
     }
     return s.name
   }
 
-  /**
-   * adds a field to this set - simple, component or group
-   * @param field
-   */
-  public add (field: ContainedField): void {
-    this.fields.push(field)
-    this.localNameToField.addUpdate(field.name, field)
-    this.addUpdate(field)
-    this.addContained(this, field)
-  }
-
   /**
    * recurses down a path to return nested set definitiom of a group or component
    * given in dot notation 'SecListGrp.NoRelatedSym.SecurityTradingRules.BaseTradingRules'
    * @param path in dot notation
    */
-  public getSet (path: string): (ContainedFieldSet | null) {
+  public getSet (path: string): (IContainedSet | null) {
     if (!path) return null
-    return path.split('.').reduce((set: ContainedFieldSet, next: string): (ContainedFieldSet | null) => {
-      return set.groups.get(next)?.definition ?? set.components.get(next)?.definition ?? null
+    return path.split('.').reduce((set: IContainedSet, next: string): (IContainedSet | null) => {
+      return set.groups.get(next) ?? set.components.get(next) ?? null
     }, this)
   }
-
-  private addUpdate (field: ContainedField): void {
-    switch (field.type) {
-      case ContainedFieldType.Simple: {
-        this.addLocalSimple(field as ContainedSimpleField)
-        break
-      }
-
-      case ContainedFieldType.Component: {
-        const cf = field as ContainedComponentField
-        const definition = cf.definition
-        if (definition.abbreviation && definition.abbreviation !== field.name) {
-          this.localNameToField.addUpdate(definition.abbreviation, field)
-        }
-        break
-      }
-
-      case ContainedFieldType.Group: {
-        const gf = field as ContainedComponentField
-        const definition = gf.definition
-        if (definition.abbreviation && definition.abbreviation !== field.name) {
-          this.localNameToField.addUpdate(definition.abbreviation, field)
-        }
-        break
-      }
-
-      default:
-        throw new Error(`unknown field type ${field.type}`)
-    }
-  }
-
-  private addLocalSimple (field: ContainedSimpleField): void {
-    const definition = field.definition
-    if (definition.abbreviation && definition.abbreviation !== definition.name) {
-      this.localNameToField.addUpdate(definition.abbreviation, field)
-    }
-    if (definition.baseCategoryAbbreviation && definition.baseCategory === this.category) {
-      this.localNameToField.addUpdate(definition.baseCategoryAbbreviation, field)
-    }
-    if (field.attribute) {
-      this.nameToLocalAttribute.addUpdate(definition.abbreviation, field)
-      this.localAttribute.push(field)
-      // an attribute for FixMl lives in attribute set not fields - in this case xml sub elements
-      this.fields.pop()
-    }
-    const tag = definition.tag
-    this.localTag[tag] = field
-    if (field.required) {
-      this.localRequired[tag] = field
-    }
-  }
-
-  private addContained (parent: ContainedFieldSet, field: ContainedField): void {
-    switch (field.type) {
-      case ContainedFieldType.Group: {
-        this.addGroupFieldDef(field as ContainedGroupField)
-        break
-      }
-
-      case ContainedFieldType.Component: {
-        this.addComponentFieldDef(field as ContainedComponentField)
-        break
-      }
-
-      case ContainedFieldType.Simple: {
-        this.addSimpleFieldDef(parent, field as ContainedSimpleField)
-        break
-      }
-
-      default:
-        throw new Error(`unknown field type ${field.type}`)
-    }
-  }
-
-  private addAllFields (containedField: ContainedFieldSet): void {
-    containedField.fields.forEach((f: ContainedField) => {
-      this.addContained(containedField, f)
-    })
-  }
-
-  private addGroupFieldDef (groupField: ContainedGroupField): void {
-    if (this.groups.containsKey(groupField.name)) {
-      return
-    }
-    const definition = groupField.definition
-    this.groups.add(groupField.name, groupField)
-    const nof = definition.noOfField
-    if (nof) {
-      const tag = nof.tag
-      this.containedTag[tag] = true
-      this.flattenedTag.push(tag)
-    }
-    this.addAllFields(definition)
-    this.mapAllBelow(definition, groupField)
-  }
-
-  private addComponentFieldDef (componentField: ContainedComponentField): void {
-    const components = this.components
-    if (components.containsKey(componentField.name)) {
-      return
-    }
-    const definition = componentField.definition
-    components.add(componentField.name, componentField)
-    this.addAllFields(definition)
-    this.mapAllBelow(definition, componentField)
-  }
-
-  public keys (): number[] {
-    const keys: string[] = Object.keys(this.containedTag)
-    const nums: number[] = new Array(keys.length)
-    for (let j: number = 0; j < keys.length; ++j) {
-      nums[j] = parseInt(keys[j], 10)
-    }
-    return nums
-  }
-
-  private mapAllBelow (set: ContainedFieldSet, field: ContainedField): void {
-    // point all tags in this component to this field.
-    const tagsBelow: number[] = set.keys()
-    for (const t of tagsBelow) {
-      this.tagToField[t] = field
-    }
-  }
-
-  private addSimpleFieldDef (parent: ContainedFieldSet, field: ContainedSimpleField): void {
-    if (this.simple.containsKey(field.name)) {
-      return
-    }
-    if (!this.firstSimple) {
-      this.firstSimple = field
-    }
-    switch (field.definition.tagType) {
-      case TagType.RawData: {
-        const dataLengthField: ContainedSimpleField = parent.fields[field.position - 1] as ContainedSimpleField
-        if (dataLengthField && dataLengthField.definition.tagType === TagType.Length) {
-          this.containedLength[dataLengthField.definition.tag] = true
-          this.containsRaw = true
-        }
-        break
-      }
-      default:
-        break
-    }
-    const tag = field.definition.tag
-    this.simple.add(field.name, field)
-    this.containedTag[tag] = true
-    this.flattenedTag.push(tag)
-    this.tagToSimple[tag] = field
-  }
 }

package/src/dictionary/contained/contained-group-field.ts

@@ -1,5 +1,5 @@
 import { ContainedField } from './contained-field'
-import { GroupFieldDefinition } from '../definition'
+import { GroupFieldDefinition } from '../definition/group-field-definition'
 import { ContainedFieldType } from './contained-field-type'
 
 export class ContainedGroupField extends ContainedField {

package/src/dictionary/contained/contained-set-builder.ts

@@ -0,0 +1,164 @@
+import { ContainedFieldSet } from './contained-field-set'
+import { ContainedField } from './contained-field'
+import { ContainedFieldType } from './contained-field-type'
+import { ContainedSimpleField } from './contained-simple-field'
+import { ContainedComponentField } from './contained-component-field'
+import { ContainedGroupField } from './contained-group-field'
+import { TagType } from '../../buffer/tag/tag-type'
+import { IContainedSet } from './contained-set'
+
+export class ContainedSetBuilder {
+  public constructor (public set: IContainedSet) {
+  }
+
+  /**
+   * adds a field to this set - simple, component or group
+   * @param field
+   */
+  public add (field: ContainedField): void {
+    this.set.fields.push(field)
+    this.set.localNameToField.set(field.name, field)
+    this.addUpdate(field)
+    this.addContained(this.set, field)
+  }
+
+  private addUpdate (field: ContainedField): void {
+    switch (field.type) {
+      case ContainedFieldType.Simple: {
+        this.addLocalSimple(field as ContainedSimpleField)
+        break
+      }
+
+      case ContainedFieldType.Component: {
+        const cf = field as ContainedComponentField
+        const definition = cf.definition
+        if (definition.abbreviation && definition.abbreviation !== field.name) {
+          this.set.localNameToField.set(definition.abbreviation, field)
+        }
+        break
+      }
+
+      case ContainedFieldType.Group: {
+        const gf = field as ContainedComponentField
+        const definition = gf.definition
+        if (definition.abbreviation && definition.abbreviation !== field.name) {
+          this.set.localNameToField.set(definition.abbreviation, field)
+        }
+        break
+      }
+
+      default:
+        throw new Error(`unknown field type ${field.type}`)
+    }
+  }
+
+  private addLocalSimple (field: ContainedSimpleField): void {
+    const definition = field.definition
+    if (definition.abbreviation && definition.abbreviation !== definition.name) {
+      this.set.localNameToField.set(definition.abbreviation, field)
+    }
+    if (definition.baseCategoryAbbreviation && definition.baseCategory === this.set.category) {
+      this.set.localNameToField.set(definition.baseCategoryAbbreviation, field)
+    }
+    if (field.attribute) {
+      this.set.nameToLocalAttribute.set(definition.abbreviation, field)
+      this.set.localAttribute.push(field)
+      // an attribute for FixMl lives in attribute set not fields - in this case xml sub elements
+      this.set.fields.pop()
+    }
+    const tag = definition.tag
+    this.set.localTag[tag] = field
+    if (field.required) {
+      this.set.localRequired[tag] = field
+    }
+  }
+
+  private addContained (parent: IContainedSet, field: ContainedField): void {
+    switch (field.type) {
+      case ContainedFieldType.Group: {
+        this.addGroupFieldDef(field as ContainedGroupField)
+        break
+      }
+
+      case ContainedFieldType.Component: {
+        this.addComponentFieldDef(field as ContainedComponentField)
+        break
+      }
+
+      case ContainedFieldType.Simple: {
+        this.addSimpleFieldDef(parent, field as ContainedSimpleField)
+        break
+      }
+
+      default:
+        throw new Error(`unknown field type ${field.type}`)
+    }
+  }
+
+  private addGroupFieldDef (groupField: ContainedGroupField): void {
+    if (this.set.groups.has(groupField.name)) {
+      return
+    }
+    const definition = groupField.definition
+    this.set.groups.set(groupField.name, definition)
+    const nof = definition.noOfField
+    if (nof) {
+      const tag = nof.tag
+      this.set.containedTag[tag] = true
+      this.set.flattenedTag.push(tag)
+    }
+    this.addAllFields(definition)
+    this.mapAllBelow(definition, groupField)
+  }
+
+  private addComponentFieldDef (componentField: ContainedComponentField): void {
+    const components = this.set.components
+    if (components.has(componentField.name)) {
+      return
+    }
+    const definition = componentField.definition
+    components.set(componentField.name, definition)
+    this.addAllFields(definition)
+    this.mapAllBelow(definition, componentField)
+  }
+
+  private mapAllBelow (set: ContainedFieldSet, field: ContainedField): void {
+    // point all tags in this component to this field.
+    const tagsBelow: number[] = set.keys()
+    for (const t of tagsBelow) {
+      this.set.tagToField[t] = field
+    }
+  }
+
+  private addSimpleFieldDef (parent: IContainedSet, field: ContainedSimpleField): void {
+    if (this.set.simple.has(field.name)) {
+      return
+    }
+    if (!this.set.firstSimple) {
+      this.set.firstSimple = field
+    }
+    switch (field.definition.tagType) {
+      case TagType.RawData: {
+        const dataLengthField: ContainedSimpleField = parent.fields[field.position - 1] as ContainedSimpleField
+        if (dataLengthField && dataLengthField.definition.tagType === TagType.Length) {
+          this.set.containedLength[dataLengthField.definition.tag] = true
+          this.set.containsRaw = true
+        }
+        break
+      }
+      default:
+        break
+    }
+    const tag = field.definition.tag
+    this.set.simple.set(field.name, field)
+    this.set.containedTag[tag] = true
+    this.set.flattenedTag.push(tag)
+    this.set.tagToSimple[tag] = field
+  }
+
+  private addAllFields (containedField: ContainedFieldSet): void {
+    containedField.fields.forEach((f: ContainedField) => {
+      this.addContained(containedField, f)
+    })
+  }
+}

package/src/dictionary/contained/contained-set.ts

@@ -0,0 +1,83 @@
+import { ContainedSimpleField } from './contained-simple-field'
+import { ContainedField } from './contained-field'
+import { INumericKeyed } from '../../collections/collection'
+import { ContainedSetType } from '../contained-set-type'
+
+export interface IContainedSet {
+  /**
+   * index of name to any group that may be present within the field list
+   */
+  readonly groups: Map<string, IContainedSet>
+  /**
+   * index of name to any component that may be present within the field list
+   */
+  readonly components: Map<string, IContainedSet>
+  /**
+   * index of name to any simple field that may be present within the field list
+   */
+  readonly simple: Map<string, ContainedSimpleField>
+  /**
+   *  sequence of fields representing this type - can be simple, group or component
+   */
+  readonly fields: ContainedField[]
+  /**
+   * any tag at any level i.e. does this set contain a tag
+   */
+  readonly containedTag: INumericKeyed<boolean>
+  /**
+   * any tag at any level ordered i.e. all tags flattened to list
+   */
+  readonly flattenedTag: number[]
+  /**
+   * any data tags contained length within this set.
+   */
+  readonly containedLength: INumericKeyed<boolean>
+  /**
+   * tags only in repository at this level, not from any at deeper levels
+   */
+  readonly localTag: INumericKeyed<ContainedSimpleField>
+  /**
+   * tags marked required at this level only
+   */
+  readonly localRequired: INumericKeyed<ContainedSimpleField>
+  /**
+   * all tags contained within this field set flattened from all levels
+   */
+  readonly tagToSimple: INumericKeyed<ContainedSimpleField>
+  /**
+   * direct any tag contained within this set to field one level down where it belongs.
+   */
+  readonly tagToField: INumericKeyed<ContainedField>
+  /**
+   * only repository directly in this set indexed by name
+   */
+  readonly localNameToField: Map<string, ContainedField>
+  /**
+   * for FixMl notation this set of fields appear as attributes i.e. <Pty ID="323" R="38">
+   */
+  readonly nameToLocalAttribute: Map<string, ContainedSimpleField>
+  /**
+   * all attributes in order of being declared
+   */
+  readonly localAttribute: ContainedSimpleField[]
+  readonly type: ContainedSetType
+  readonly name: string
+  readonly category: string | null
+  readonly abbreviation: string | null
+  readonly description: string | null
+  /**
+   * at any level on this set, first declared simple field
+   */
+  firstSimple: (ContainedSimpleField | null)
+  containsRaw: boolean
+
+  toString: () => string
+
+  getPrefix: () => string
+
+  getFieldName: (tag: number) => string
+
+  getSet: (path: string) => IContainedSet | null
+
+  keys: () => number[]
+}

package/src/dictionary/contained/contained-simple-field.ts

@@ -1,5 +1,5 @@
 import { ContainedField } from './contained-field'
-import { SimpleFieldDefinition } from '../definition'
+import { SimpleFieldDefinition } from '../definition/simple-field-definition'
 import { ContainedFieldType } from './contained-field-type'
 
 export class ContainedSimpleField extends ContainedField {

package/src/dictionary/contained/index.ts

@@ -2,7 +2,10 @@ export * from './contained-component-field'
 export * from './contained-field-type'
 export * from './contained-field'
 export * from './contained-field-dispatch'
-export * from './contained-field-set'
+export * from './fields-dispatch'
+export * from './contained-set'
+export * from './contained-set-builder'
 export * from './contained-group-field'
 export * from './contained-simple-field'
 export * from './fields-dispatch'
+export * from './contained-set-builder'

package/src/dictionary/definition/category-simple-set.ts

@@ -1,8 +1,7 @@
 import { SimpleFieldDefinition } from './simple-field-definition'
-import { Dictionary } from '../../collections'
 
 export class CategorySimpleSet {
-  public readonly simple: Dictionary<SimpleFieldDefinition> = new Dictionary<SimpleFieldDefinition>()
+  public readonly simple: Map<string, SimpleFieldDefinition> = new Map<string, SimpleFieldDefinition>()
   constructor (public readonly category: string) {
   }
 }

package/src/dictionary/definition/component-field-definition.ts

@@ -1,4 +1,4 @@
-import { ContainedFieldSet } from '../contained'
+import { ContainedFieldSet } from '../contained/contained-field-set'
 import { ContainedSetType } from '../contained-set-type'
 
 export class ComponentFieldDefinition extends ContainedFieldSet {