ifc-expressions/dist/mjs/compiler/TypeManager.js

Parsing and evaluation of IFC expressions

import { Type, Types } from "../type/Types.js";
import { ExpressionTypeError } from "../error/ExpressionTypeError.js";
export class TypeManager {
    constructor() {
        this.types = new Map();
    }
    setType(parserRuleContext, type) {
        this.types.set(parserRuleContext, type);
    }
    getType(parserRuleContext) {
        return this.types.get(parserRuleContext);
    }
    copyTypeFrom(ctx, from) {
        const theType = this.types.get(from);
        this.types.set(ctx, theType);
    }
    requireString(ctx) {
        const actualType = this.types.get(ctx);
        Types.requireWeakIsAssignableFrom(Type.STRING, this.types.get(ctx), () => new ExpressionTypeError(`expected type string, actual type is ${actualType.getName()}`, ctx));
    }
    requireBoolean(ctx) {
        const actualType = this.types.get(ctx);
        Types.requireWeakIsAssignableFrom(Type.BOOLEAN, this.types.get(ctx), () => new ExpressionTypeError(`expected type boolean, actual type is ${actualType.getName()}`, ctx));
    }
    requireLogicalOrBoolean(ctx) {
        return this.requireOneOf(ctx, Type.BOOLEAN, Type.LOGICAL);
    }
    requireOneOf(ctx, ...types) {
        const requiredType = Types.or(...types);
        const actualType = this.types.get(ctx);
        Types.requireWeakIsAssignableFrom(requiredType, this.types.get(ctx), () => new ExpressionTypeError(`expected type ${requiredType}, actual type is ${actualType.getName()}`, ctx));
    }
    requireNumeric(ctx) {
        const actualType = this.types.get(ctx);
        Types.requireWeakIsAssignableFrom(Type.NUMERIC, actualType, () => new ExpressionTypeError(`expected type numeric, actual type is ${actualType.getName()}`, ctx));
    }
    requireTypesOverlap(ctxA, ctxB) {
        Types.requireTypesOverlap(this.types.get(ctxA), this.types.get(ctxB), () => new ExpressionTypeError(`Types ${this.types.get(ctxA).getName()} and ${this.types
            .get(ctxB)
            .getName()} are required to overlap but they don't.`, ctxA));
    }
    isType(type, ...ctxs) {
        return ctxs.every((ctx) => Types.isType(this.types.get(ctx), type));
    }
    overlapsWith(type, ...ctxs) {
        return ctxs.every((ctx) => type.overlapsWith(this.types.get(ctx)));
    }
    isString(...ctxs) {
        return this.isType(Type.STRING, ...ctxs);
    }
    overlapsWithString(...ctxs) {
        return this.overlapsWith(Type.STRING, ...ctxs);
    }
    isBoolean(...ctxs) {
        return this.isType(Type.BOOLEAN, ...ctxs);
    }
    isLogical(...ctxs) {
        return this.isType(Type.LOGICAL, ...ctxs);
    }
    overlapsWithBoolean(...ctxs) {
        return this.overlapsWith(Type.BOOLEAN, ...ctxs);
    }
    overlapsWithLogical(...ctxs) {
        return this.overlapsWith(Type.LOGICAL, ...ctxs);
    }
    isNumeric(...ctxs) {
        return this.isType(Type.NUMERIC, ...ctxs);
    }
    overlapsWithNumeric(...ctxs) {
        return this.overlapsWith(Type.NUMERIC, ...ctxs);
    }
}
//# sourceMappingURL=TypeManager.js.map