jspurefix/dist/dictionary/definition/fix-definitions.js

pure node js fix engine

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.FixDefinitions = void 0;
const category_simple_set_1 = require("./category-simple-set");
const fix_version_parser_1 = require("./fix-version-parser");
class FixDefinitions {
    constructor(source, version) {
        this.source = source;
        this.version = version;
        this.simple = new Map();
        this.component = new Map();
        this.message = new Map();
        this.tagToSimple = {};
        this.categorySimple = new Map();
    }
    getMajor() {
        return fix_version_parser_1.FixVersionParser.getMajor(this.version);
    }
    getMinor() {
        return fix_version_parser_1.FixVersionParser.getMinor(this.version);
    }
    getServicePack() {
        return fix_version_parser_1.FixVersionParser.getServicePack(this.version);
    }
    toString() {
        const msgs = this.message.values();
        const strs = [];
        for (const message of msgs) {
            strs.push(message.toString());
        }
        return JSON.stringify(strs, null, 4);
    }
    containedSet(type) {
        var _a;
        return (_a = this.message.get(type)) !== null && _a !== void 0 ? _a : this.component.get(type);
    }
    getSet(path) {
        var _a, _b;
        const idx = path.indexOf('.');
        let name = path;
        if (idx > 0) {
            name = path.substring(0, idx);
        }
        else {
            return this.message.get(name);
        }
        return (_b = (_a = this.message.get(name)) === null || _a === void 0 ? void 0 : _a.getSet(path.substring(idx + 1))) !== null && _b !== void 0 ? _b : undefined;
    }
    addMessage(message) {
        const messages = this.message;
        messages.set(message.name, message);
        if (message.msgType && message.msgType !== message.name) {
            messages.set(message.msgType, message);
        }
        if (message.abbreviation) {
            if (message.abbreviation !== message.name) {
                messages.set(message.abbreviation, message);
            }
        }
    }
    addComponentFieldDef(field) {
        this.component.set(field.name, field);
    }
    getSimple(name, cat) {
        let sf;
        if (cat) {
            const category = this.categorySimple.get(cat);
            if (category) {
                sf = category.simple.get(name);
            }
        }
        if (!sf) {
            sf = this.simple.get(name);
        }
        return sf;
    }
    addSimpleAlias(from, to) {
        const simple = this.simple.get(from);
        if (simple) {
            this.simple.set(to, simple);
        }
    }
    addSimpleFieldDef(field, typeName = null) {
        this.assignCategory(field);
        const simple = this.simple;
        simple.set(field.num, field);
        simple.set(field.name, field);
        this.tagToSimple[field.tag] = field;
        if (field.abbreviation && field.abbreviation !== field.name) {
            if (!simple.has(field.abbreviation)) {
                simple.set(field.abbreviation, field);
            }
        }
        if (typeName && typeName !== field.name && field.name && field.type) {
            simple.set(typeName, field);
        }
    }
    assignCategory(field) {
        if (field.baseCategory && field.baseCategoryAbbreviation) {
            let category = this.categorySimple.get(field.baseCategory);
            if (!category) {
                category = new category_simple_set_1.CategorySimpleSet(field.baseCategory);
                this.categorySimple.set(field.baseCategory, category);
            }
            category.simple.set(field.baseCategoryAbbreviation, field);
        }
    }
}
exports.FixDefinitions = FixDefinitions;
//# sourceMappingURL=fix-definitions.js.map