jspurefix 3.5.0 → 4.0.0

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 {

package/src/dictionary/parser/fix-repository/repository.ts

@@ -3,8 +3,14 @@ import {
   SimpleFieldDefinition, GroupFieldDefinition, ComponentFieldDefinition,
   MessageDefinition, FixDefinitions
 } from '../../definition'
-import { Dictionary } from '../../../collections'
-import { ContainedFieldSet, ContainedComponentField, ContainedGroupField, ContainedSimpleField } from '../../contained'
+
+import {
+  IContainedSet,
+  ContainedComponentField,
+  ContainedGroupField,
+  ContainedSimpleField,
+  ContainedSetBuilder
+} from '../../contained'
 import { FixVersion } from '../../fix-versions'
 import { GetJsFixLogger, IJsFixLogger } from '../../../config'
 import { FixDefinitionSource } from '../../fix-definition-source'
@@ -28,10 +34,10 @@ export class Repository {
   public includesAbbreviations: boolean
   // derived from above
   public readonly definitions: FixDefinitions
-  private readonly groupLookup: Dictionary<GroupFieldDefinition> = new Dictionary<GroupFieldDefinition>()
-  private contentLookup: Dictionary<IRepositoryMsgContent[]>
-  private componentLookup: Dictionary<IRepositoryComponent>
-  private dataTypeLookup: Dictionary<IRepositoryDataType>
+  private readonly groupLookup: Map<string, GroupFieldDefinition> = new Map<string, GroupFieldDefinition>()
+  private contentLookup: Map<string, IRepositoryMsgContent[]>
+  private componentLookup: Map<string, IRepositoryComponent>
+  private dataTypeLookup: Map<string, IRepositoryDataType>
   private readonly logger: IJsFixLogger
 
   constructor (public readonly version: FixVersion, public readonly getLogger: GetJsFixLogger) {
@@ -104,9 +110,9 @@ export class Repository {
   private summarise (): void {
     const logger = this.logger
     const definitions = this.definitions
-    logger.info(`definitions: ${definitions.simple.count()} fields`)
-    logger.info(`definitions: ${definitions.component.count()} components`)
-    logger.info(`definitions: ${definitions.message.count()} messages`)
+    logger.info(`definitions: ${definitions.simple.size} fields`)
+    logger.info(`definitions: ${definitions.component.size} components`)
+    logger.info(`definitions: ${definitions.message.size} messages`)
   }
 
   private toDefinitions (): void {
@@ -129,16 +135,16 @@ export class Repository {
   }
 
   private header (): void {
-    const h: ComponentFieldDefinition | null = this.definitions.component.get('StandardHeader')
+    const h: ComponentFieldDefinition | undefined = this.definitions.component.get('StandardHeader')
     if (h) {
-      this.definitions.component.add('header', h)
+      this.definitions.component.set('header', h)
     }
   }
 
   private trailer (): void {
-    const t: ComponentFieldDefinition | null = this.definitions.component.get('StandardTrailer')
+    const t: ComponentFieldDefinition | undefined = this.definitions.component.get('StandardTrailer')
     if (t) {
-      this.definitions.component.add('trailer', t)
+      this.definitions.component.set('trailer', t)
     }
   }
 
@@ -189,8 +195,8 @@ export class Repository {
     this.dataTypeLookup = this.types()
     const definitions = this.definitions
     const types = this.dataTypeLookup
-    types.remove('boolean')
-    types.remove('data')
+    types.delete('boolean')
+    types.delete('data')
     this.Fields.forEach((f: IRepositoryField) => {
       const type = this.getType(f)
       definitions.addSimpleFieldDef(Repository.makeSimple(f, type))
@@ -198,32 +204,33 @@ export class Repository {
     this.fieldEnums()
   }
 
-  private contents (): Dictionary<IRepositoryMsgContent[]> {
+  private contents (): Map<string, IRepositoryMsgContent[]> {
     return this.MsgContents.reduce((a, current) => {
-      let content: IRepositoryMsgContent[] | null = a.get(current.ComponentID)
+      let content: IRepositoryMsgContent[] | undefined = a.get(current.ComponentID)
       if (!content) {
         content = []
-        a.add(current.ComponentID, content)
+        a.set(current.ComponentID, content)
       }
       content[content.length] = current
       return a
-    }, new Dictionary<IRepositoryMsgContent[]>())
+    }, new Map<string, IRepositoryMsgContent[]>())
   }
 
-  private resolveToFieldSet (content: IRepositoryMsgContent[], parentSet: ContainedFieldSet): void {
+  private resolveToFieldSet (content: IRepositoryMsgContent[], parentSet: IContainedSet): void {
+    const builder = new ContainedSetBuilder(parentSet)
     content.forEach((current: IRepositoryMsgContent) => {
       const required: boolean = current.Reqd === '1'
       const tag: number = parseInt(current.TagText, 10)
       if (!isNaN(tag)) {
         const sf: SimpleFieldDefinition = this.definitions.tagToSimple[tag]
         if (sf) {
-          parentSet.add(new ContainedSimpleField(sf, parentSet.fields.length, required, false))
+          builder.add(new ContainedSimpleField(sf, parentSet.fields.length, required, false))
         }
       } else {
         // is there a definition for this type yet create.
-        let childSet: ContainedFieldSet | null = this.definitions.component.get(current.TagText)
+        let childSet: IContainedSet | undefined = this.definitions.component.get(current.TagText)
         if (!childSet) {
-          const cl: IRepositoryComponent | null = this.componentLookup.get(current.TagText)
+          const cl: IRepositoryComponent | undefined = this.componentLookup.get(current.TagText)
           if (cl) {
             childSet = this.resolve(cl)
           }
@@ -231,12 +238,12 @@ export class Repository {
         if (childSet) {
           switch (childSet.type) {
             case ContainedSetType.Component: {
-              parentSet.add(new ContainedComponentField(childSet as ComponentFieldDefinition, parentSet.fields.length, required))
+              builder.add(new ContainedComponentField(childSet as ComponentFieldDefinition, parentSet.fields.length, required))
               break
             }
 
             case ContainedSetType.Group: {
-              parentSet.add(new ContainedGroupField(childSet as GroupFieldDefinition, parentSet.fields.length, required))
+              builder.add(new ContainedGroupField(childSet as GroupFieldDefinition, parentSet.fields.length, required))
               break
             }
 
@@ -250,24 +257,24 @@ export class Repository {
     })
   }
 
-  private resolve (c: IRepositoryComponent): ContainedFieldSet {
+  private resolve (c: IRepositoryComponent): IContainedSet {
     switch (c.ComponentType) {
       case 'ImplicitBlockRepeating':
       case 'BlockRepeating': {
-        const content: IRepositoryMsgContent[] | null = this.contentLookup.get(c.ComponentID) ?? []
+        const content: IRepositoryMsgContent[] | undefined = this.contentLookup.get(c.ComponentID) ?? []
         const noField: SimpleFieldDefinition = this.definitions.tagToSimple[parseInt(content[0].TagText, 10)]
-        let def: GroupFieldDefinition | null = this.groupLookup.get(c.ComponentID)
+        let def: GroupFieldDefinition | undefined = this.groupLookup.get(c.ComponentID)
         if (!def) {
           def = new GroupFieldDefinition(c.Name, c.AbbrName, c.CategoryID, noField, c.Description)
           this.resolveToFieldSet(content.slice(1), def)
-          this.groupLookup.add(c.ComponentID, def)
+          this.groupLookup.set(c.ComponentID, def)
         }
         return def
       }
 
       default: {
         const content: IRepositoryMsgContent[] | null = this.contentLookup.get(c.ComponentID) ?? []
-        let def: ComponentFieldDefinition | null = this.definitions.component.get(c.Name)
+        let def: ComponentFieldDefinition | undefined = this.definitions.component.get(c.Name)
         if (!def) {
           def = new ComponentFieldDefinition(c.Name, c.AbbrName, c.CategoryID, c.Description)
           this.resolveToFieldSet(content, def)
@@ -281,7 +288,7 @@ export class Repository {
   private message (m: IRepositoryMessage): MessageDefinition {
     const definitions = this.definitions
     const content: IRepositoryMsgContent[] = this.contentLookup.get(m.ComponentID) ?? []
-    let def: MessageDefinition | null = definitions.message.get(m.Name)
+    let def: MessageDefinition | undefined = definitions.message.get(m.Name)
     if (!def) {
       def = new MessageDefinition(m.Name, m.AbbrName, m.MsgType, m.CategoryID, m.Description)
       this.resolveToFieldSet(content, def)
@@ -290,18 +297,18 @@ export class Repository {
     return def
   }
 
-  private components (): Dictionary<IRepositoryComponent> {
-    return this.Components.reduce((a: Dictionary<IRepositoryComponent>, current: IRepositoryComponent) => {
-      a.add(current.Name, current)
-      a.add(current.ComponentID, current)
+  private components (): Map<string, IRepositoryComponent> {
+    return this.Components.reduce((a: Map<string, IRepositoryComponent>, current: IRepositoryComponent) => {
+      a.set(current.Name, current)
+      a.set(current.ComponentID, current)
       return a
-    }, new Dictionary<IRepositoryComponent>())
+    }, new Map<string, IRepositoryComponent>())
   }
 
-  private types (): Dictionary<IRepositoryDataType> {
-    return this.DataTypes.reduce((a: Dictionary<IRepositoryDataType>, current: IRepositoryDataType) => {
-      a.add(current.Name, current)
+  private types (): Map<string, IRepositoryDataType> {
+    return this.DataTypes.reduce((a: Map<string, IRepositoryDataType>, current: IRepositoryDataType) => {
+      a.set(current.Name, current)
       return a
-    }, new Dictionary<IRepositoryDataType>())
+    }, new Map<string, IRepositoryDataType>())
   }
 }