jspurefix 3.4.0 → 4.0.0

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 {

package/src/dictionary/definition/fix-definitions.ts

@@ -1,30 +1,29 @@
 import { INumericKeyed } from '../../collections/collection'
-import { Dictionary } from '../../collections'
 import { ComponentFieldDefinition } from './component-field-definition'
 import { MessageDefinition } from './message-definition'
 import { SimpleFieldDefinition } from './simple-field-definition'
 import { FixVersion } from '../fix-versions'
 import { CategorySimpleSet } from './category-simple-set'
-import { ContainedFieldSet } from '../contained'
 import { FixDefinitionSource } from '../fix-definition-source'
 import { FixVersionParser } from './fix-version-parser'
+import { IContainedSet } from '../contained/contained-set'
 
 export class FixDefinitions {
   /**
    * all simple fields defined from source definition indexed via name
    * e.g. 'BeginString'
    */
-  public readonly simple: Dictionary<SimpleFieldDefinition> = new Dictionary<SimpleFieldDefinition>()
+  public readonly simple: Map<string, SimpleFieldDefinition> = new Map<string, SimpleFieldDefinition>()
   /**
    * all components defined from source definition indexed via name
    * e.g. 'Instrument'
    */
-  public readonly component: Dictionary<ComponentFieldDefinition> = new Dictionary<ComponentFieldDefinition>()
+  public readonly component: Map<string, ComponentFieldDefinition> = new Map<string, ComponentFieldDefinition>()
   /**
    * all messages defined from source definition indexed via name
    * e.g. 'Logon'
    */
-  public readonly message: Dictionary<MessageDefinition> = new Dictionary<MessageDefinition>()
+  public readonly message: Map<string, MessageDefinition> = new Map<string, MessageDefinition>()
   /**
    * all messages defined from source definition indexed via tag id
    * e.g. 8
@@ -33,7 +32,7 @@ export class FixDefinitions {
   /**
    * all fields within a category indexed via name used for FIXML
    */
-  public readonly categorySimple: Dictionary<CategorySimpleSet> = new Dictionary<CategorySimpleSet>()
+  public readonly categorySimple: Map<string, CategorySimpleSet> = new Map<string, CategorySimpleSet>()
 
   constructor (public readonly source: FixDefinitionSource, public readonly version: FixVersion) {
   }
@@ -52,11 +51,14 @@ export class FixDefinitions {
 
   public toString (): string {
     const msgs = this.message.values()
-    const strs: String[] = msgs.map(m => m.toString())
+    const strs: String[] = []
+    for (const message of msgs) {
+      strs.push(message.toString())
+    }
     return JSON.stringify(strs, null, 4)
   }
 
-  public containedSet (type: string): ContainedFieldSet | null {
+  public containedSet (type: string): IContainedSet | undefined {
     return this.message.get(type) ?? this.component.get(type)
   }
 
@@ -66,7 +68,7 @@ export class FixDefinitions {
    * 'SecurityList.SecListGrp.NoRelatedSym.SecurityTradingRules'
    * @param path dot denoted path too field set nested from root
    */
-  public getSet (path: string): ContainedFieldSet | null {
+  public getSet (path: string): IContainedSet | undefined {
     const idx = path.indexOf('.')
     let name: string = path
     if (idx > 0) {
@@ -74,7 +76,7 @@ export class FixDefinitions {
     } else {
       return this.message.get(name)
     }
-    return this.message.get(name)?.getSet(path.substring(idx + 1)) ?? null
+    return this.message.get(name)?.getSet(path.substring(idx + 1)) ?? undefined
   }
 
   /**
@@ -84,13 +86,13 @@ export class FixDefinitions {
    */
   public addMessage (message: MessageDefinition): void {
     const messages = this.message
-    messages.addUpdate(message.name, message)
+    messages.set(message.name, message)
     if (message.msgType && message.msgType !== message.name) {
-      messages.addUpdate(message.msgType, message)
+      messages.set(message.msgType, message)
     }
     if (message.abbreviation) {
       if (message.abbreviation !== message.name) {
-        messages.addUpdate(message.abbreviation, message)
+        messages.set(message.abbreviation, message)
       }
     }
   }
@@ -100,7 +102,7 @@ export class FixDefinitions {
    * @param field
    */
   public addComponentFieldDef (field: ComponentFieldDefinition): void {
-    this.component.addUpdate(field.name, field)
+    this.component.set(field.name, field)
   }
 
   /**
@@ -109,10 +111,10 @@ export class FixDefinitions {
    * @param name of the field to fetch
    * @param cat optional category from which field belongs
    */
-  public getSimple (name: string, cat?: string | null): SimpleFieldDefinition | null {
-    let sf: SimpleFieldDefinition | null = null
+  public getSimple (name: string, cat?: string | null): SimpleFieldDefinition | undefined {
+    let sf: SimpleFieldDefinition | undefined
     if (cat) {
-      const category: CategorySimpleSet | null = this.categorySimple.get(cat)
+      const category = this.categorySimple.get(cat)
       if (category) {
         sf = category.simple.get(name)
       }
@@ -131,7 +133,7 @@ export class FixDefinitions {
   public addSimpleAlias (from: string, to: string): void {
     const simple = this.simple.get(from)
     if (simple) {
-      this.simple.addUpdate(to, simple)
+      this.simple.set(to, simple)
     }
   }
 
@@ -144,27 +146,27 @@ export class FixDefinitions {
   public addSimpleFieldDef (field: SimpleFieldDefinition, typeName: string | null = null): void {
     this.assignCategory(field)
     const simple = this.simple
-    simple.addUpdate(field.num, field)
-    simple.addUpdate(field.name, field)
+    simple.set(field.num, field)
+    simple.set(field.name, field)
     this.tagToSimple[field.tag] = field
     if (field.abbreviation && field.abbreviation !== field.name) {
-      if (!simple.containsKey(field.abbreviation)) {
-        simple.addUpdate(field.abbreviation, field)
+      if (!simple.has(field.abbreviation)) {
+        simple.set(field.abbreviation, field)
       }
     }
     if (typeName && typeName !== field.name && field.name && field.type) {
-      simple.addUpdate(typeName, field)
+      simple.set(typeName, field)
     }
   }
 
   private assignCategory (field: SimpleFieldDefinition): void {
     if (field.baseCategory && field.baseCategoryAbbreviation) {
-      let category: CategorySimpleSet | null = this.categorySimple.get(field.baseCategory)
+      let category = this.categorySimple.get(field.baseCategory)
       if (!category) {
         category = new CategorySimpleSet(field.baseCategory)
-        this.categorySimple.add(field.baseCategory, category)
+        this.categorySimple.set(field.baseCategory, category)
       }
-      category.simple.addUpdate(field.baseCategoryAbbreviation, field)
+      category.simple.set(field.baseCategoryAbbreviation, field)
     }
   }
 }

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

@@ -1,4 +1,4 @@
-import { ContainedFieldSet } from '../contained'
+import { ContainedFieldSet } from '../contained/contained-field-set'
 import { SimpleFieldDefinition } from './simple-field-definition'
 import { ContainedSetType } from '../contained-set-type'
 

package/src/dictionary/definition/message-definition.ts

@@ -1,16 +1,16 @@
-import { ContainedFieldSet } from '../contained'
+import { ContainedFieldSet } from '../contained/contained-field-set'
 import { ContainedSetType } from '../contained-set-type'
 
 export class MessageDefinition extends ContainedFieldSet {
-  constructor (public readonly name: string,
-    public readonly abbreviation: string,
+  constructor (readonly name: string,
+    readonly abbreviation: string,
     public readonly msgType: string,
-    public readonly category: string,
-    public readonly description: string | null) {
+    readonly category: string,
+    readonly description: string | null) {
     super(ContainedSetType.Msg, name, category, abbreviation, description)
   }
 
-  public getPrefix (): string {
+  getPrefix (): string {
     return `M.${this.msgType}`
   }
 }

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

@@ -1,4 +1,3 @@
-import { Dictionary } from '../../collections'
 import { FieldEnum } from '../field-enum'
 import { Tags } from '../../buffer/tag/tags'
 import { AsciiChars } from '../../buffer/ascii/ascii-chars'
@@ -8,8 +7,8 @@ import { TagType } from '../../buffer/tag/tag-type'
 export class SimpleFieldDefinition {
   public readonly tag: number
   public readonly tagType: TagType
-  public enums: Dictionary<FieldEnum>
-  public enumVals: Dictionary<boolean>
+  public enums: Map<string, FieldEnum>
+  public enumVals: Map<string, boolean>
 
   constructor (public readonly num: string,
     public readonly name: string,
@@ -31,7 +30,7 @@ export class SimpleFieldDefinition {
     if (!enums) {
       return false
     }
-    return enums.get(key) != null
+    return enums.has(key)
   }
 
   public resolveEnum (key: string): string {
@@ -39,7 +38,7 @@ export class SimpleFieldDefinition {
     if (!enums) {
       return key
     }
-    const e: FieldEnum | null = enums.get(key)
+    const e: FieldEnum | undefined = enums.get(key)
     if (e) {
       return e.val
     }
@@ -55,7 +54,7 @@ export class SimpleFieldDefinition {
     if (atDigit) {
       converted = `E${converted}`
     }
-    if (this.enumVals.containsKey(converted)) {
+    if (this.enumVals.has(converted)) {
       converted = `${converted}2`
     }
     return converted
@@ -65,13 +64,13 @@ export class SimpleFieldDefinition {
     let enums = this.enums
     let enumVals = this.enumVals
     if (enums == null) {
-      this.enums = enums = new Dictionary<FieldEnum>()
-      this.enumVals = enumVals = new Dictionary<boolean>()
+      this.enums = enums = new Map<string, FieldEnum>()
+      this.enumVals = enumVals = new Map<string, boolean>()
     }
     if (!description) description = val
     val = this.patchEnumValue(val)
-    enums.add(key, new FieldEnum(key, val, description ?? ''))
-    enumVals.add(val, true)
+    enums.set(key, new FieldEnum(key, val, description ?? ''))
+    enumVals.set(val, true)
   }
 
   public toString (): string {