pddl-workspace/dist/expression.js

PDDL Workspace

/*
 * Copyright (c) Jan Dolejsi 2023. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for license information.
 */
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.and = exports.not = exports.atStart = exports.atEnd = exports.overAll = exports.expression = exports.EqualityNode = exports.DurationExpressionNode = exports.OverAll = exports.AtEnd = exports.AtStart = exports.Not = exports.NAryLogicalExpression = exports.BinaryExpressionNode = exports.UnaryExpressionNode = exports.VariableNode = exports.VariableDeclarationNode = exports.ExpressionNode = void 0;
class ExpressionNode {
}
exports.ExpressionNode = ExpressionNode;
class VariableDeclarationNode extends ExpressionNode {
    constructor(variable) {
        super();
        this.variable = variable;
    }
    toPddlString() {
        return '(' + this.variable.getFullName() + ')';
    }
}
exports.VariableDeclarationNode = VariableDeclarationNode;
class VariableNode extends ExpressionNode {
    constructor(variable) {
        super();
        this.variable = variable;
    }
    toPddlString() {
        return '(' + this.variable.declaredNameWithoutTypes + ')';
    }
}
exports.VariableNode = VariableNode;
class UnaryExpressionNode extends ExpressionNode {
    constructor(nested, keyword) {
        super();
        this.nested = nested;
        this.keyword = keyword;
    }
    toPddlString() {
        return '(' + this.keyword + ' ' + this.nested.toPddlString() + ')';
    }
}
exports.UnaryExpressionNode = UnaryExpressionNode;
class BinaryExpressionNode extends ExpressionNode {
    constructor(left, right, keyword) {
        super();
        this.left = left;
        this.right = right;
        this.keyword = keyword;
    }
    toPddlString() {
        return '(' + this.keyword + ' ' + this.left.toPddlString() + ' ' + this.right.toPddlString() + ')';
    }
}
exports.BinaryExpressionNode = BinaryExpressionNode;
class NAryLogicalExpression extends ExpressionNode {
    constructor(operands, keyword) {
        super();
        this.operands = operands;
        this.keyword = keyword;
    }
    toPddlString() {
        return '(' + this.keyword + ' ' + this.operands.map(o => o.toPddlString()).join(' ') + ')';
    }
}
exports.NAryLogicalExpression = NAryLogicalExpression;
class Not extends UnaryExpressionNode {
    constructor(nested) {
        super(nested, 'not');
        this.nested = nested;
    }
}
exports.Not = Not;
class AtStart extends UnaryExpressionNode {
    constructor(nested) {
        super(nested, 'at start');
        this.nested = nested;
    }
}
exports.AtStart = AtStart;
class AtEnd extends UnaryExpressionNode {
    constructor(nested) {
        super(nested, 'at end');
        this.nested = nested;
    }
}
exports.AtEnd = AtEnd;
class OverAll extends UnaryExpressionNode {
    constructor(nested) {
        super(nested, 'over all');
        this.nested = nested;
    }
}
exports.OverAll = OverAll;
class DurationExpressionNode extends ExpressionNode {
    constructor() {
        super();
    }
    toPddlString() {
        return '?duration';
    }
}
exports.DurationExpressionNode = DurationExpressionNode;
class EqualityNode extends BinaryExpressionNode {
    constructor(left, right) {
        super(left, right, '=');
        this.left = left;
        this.right = right;
    }
}
exports.EqualityNode = EqualityNode;
function expression(variable) {
    return new VariableNode(variable);
}
exports.expression = expression;
function overAll(expression) {
    return new OverAll(expression);
}
exports.overAll = overAll;
function atEnd(expression) {
    return new AtEnd(expression);
}
exports.atEnd = atEnd;
function atStart(expression) {
    return new AtStart(expression);
}
exports.atStart = atStart;
function not(variable) {
    return new Not(expression(variable));
}
exports.not = not;
function and(conjuncts) {
    return new NAryLogicalExpression(conjuncts, 'and');
}
exports.and = and;
//# sourceMappingURL=expression.js.map