/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(OrGdAstNode astNode)
{
OrExpression orExpression = new OrExpression();
astNode.Arguments.ForEach(arg => orExpression.Arguments.Add(MasterExporter.ToExpression(arg)));
ExpressionData = orExpression;
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(PredicatePEffectAstNode astNode)
{
PredicateEffect predicate = new PredicateEffect(astNode.Name);
astNode.Terms.ForEach(term => predicate.Terms.Add(MasterExporter.ToTerm(term)));
EffectsData.Add(predicate);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(PredicateGdAstNode astNode)
{
PredicateExpression predicate = new PredicateExpression(astNode.Name);
astNode.Terms.ForEach(term => predicate.Terms.Add(MasterExporter.ToTerm(term)));
ExpressionData = predicate;
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(AndGdAstNode astNode)
{
AndExpression andExpression = new AndExpression();
astNode.Arguments.ForEach(arg => andExpression.Arguments.Add(MasterExporter.ToExpression(arg)));
ExpressionData = andExpression;
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(EqualsOpInitElemAstNode astNode)
{
var numericFunction = MasterExporter.ToBasicNumericFunctionTerm(astNode.Term1);
var numberAstNode = astNode.Term2 as NumberTermAstNode;
if (numericFunction != null && numberAstNode != null)
{
InitElementData = new EqualsNumericFunctionInitElement(numericFunction, numberAstNode.Number);
return;
}
var objectFunction = MasterExporter.ToBasicObjectFunctionTerm(astNode.Term1);
var term2IdentifierAstNode = astNode.Term2 as IdentifierTermAstNode;
if (objectFunction != null && term2IdentifierAstNode != null)
{
InitElementData = new EqualsObjectFunctionInitElement(objectFunction, MasterExporter.ToConstantTerm(term2IdentifierAstNode));
return;
}
var term1IdentifierAstNode = astNode.Term1 as IdentifierTermAstNode;
if (term1IdentifierAstNode != null && term2IdentifierAstNode != null)
{
InitElementData = new EqualsInitElement(MasterExporter.ToConstantTerm(astNode.Term1), MasterExporter.ToConstantTerm(astNode.Term2));
}
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(FunctionTermAstNode astNode)
{
NumericFunction function = new NumericFunction(astNode.Name);
astNode.Terms.ForEach(term => function.Terms.Add(MasterExporter.ToTerm(term)));
ExpressionData = function;
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(FunctionTermAstNode astNode)
{
ObjectFunctionTerm functionTerm = new ObjectFunctionTerm(astNode.Name);
astNode.Terms.ForEach(argTerm => functionTerm.Terms.Add(MasterExporter.ToTerm(argTerm)));
TermData = functionTerm;
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(AssignPEffectAstNode astNode)
{
if (astNode.AssignOperator == Traits.AssignOperator.ASSIGN && MasterExporter.IsTerm(astNode.Argument2))
{
EffectsData.Add(new ObjectAssignEffect((ObjectFunctionTerm)MasterExporter.ToTerm(astNode.Argument1), MasterExporter.ToTerm(astNode.Argument2)));
}
else
{
EffectsData.Add(new NumericAssignEffect(astNode.AssignOperator, (NumericFunction)MasterExporter.ToNumericExpression(astNode.Argument1), MasterExporter.ToNumericExpression(astNode.Argument2)));
}
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(EqualsOpGdAstNode astNode)
{
if (MasterExporter.IsNumericExpression(astNode.Argument1) && MasterExporter.IsNumericExpression(astNode.Argument2))
{
ExpressionData = new NumericCompareExpression(Traits.NumericComparer.EQ, MasterExporter.ToNumericExpression(astNode.Argument1), MasterExporter.ToNumericExpression(astNode.Argument2));
}
else
{
ExpressionData = new EqualsExpression(MasterExporter.ToTerm(astNode.Argument1), MasterExporter.ToTerm(astNode.Argument2));
}
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(DomainDerivedPredAstNode astNode)
{
DerivedPredicate newDerivedPredicate = new DerivedPredicate
{
Expression = MasterExporter.ToExpression(astNode.Expression),
Predicate = new Predicate(astNode.Predicate.Name)
};
astNode.Predicate.Arguments.TypedIdentifiers.ForEach(termElem => newDerivedPredicate.Predicate.Terms.Add(new DefinitionTerm(termElem.Item1, termElem.Item2.Split(';'))));
DomainData.DerivedPredicates.Add(newDerivedPredicate);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(DomainActionAstNode astNode)
{
Action newAction = new Action
{
Name = astNode.Name,
Parameters = MasterExporter.ToParameters(astNode.Parameters),
Preconditions = MasterExporter.ToPreconditions(astNode.Preconditions),
Effects = MasterExporter.ToEffects(astNode.Effects)
};
DomainData.Actions.Add(newAction);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(FunctionTermAstNode astNode)
{
if (astNode.Name.Equals("total-time"))
{
ExpressionData = new MetricTotalTime();
}
else
{
MetricNumericFunction function = new MetricNumericFunction(astNode.Name);
astNode.Terms.ForEach(term => function.Terms.Add(MasterExporter.ToConstantTerm(term)));
ExpressionData = function;
}
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(DomainDurActionAstNode astNode)
{
DurativeAction newDurativeAction = new DurativeAction
{
Name = astNode.Name,
Parameters = MasterExporter.ToParameters(astNode.Parameters),
Durations = MasterExporter.ToDurativeConstraints(astNode.DurationConstraint),
Conditions = MasterExporter.ToDurativeConditions(astNode.Condition),
Effects = MasterExporter.ToDurativeEffects(astNode.Effect)
};
DomainData.DurativeActions.Add(newDurativeAction);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(IdentifierTermAstNode astNode)
{
if (MasterExporter.IsIdentifierTermObjectFunction(astNode))
{
TermData = new ObjectFunctionTerm(astNode.Name);
}
else if (MasterExporter.IsIdentifierTermVariable(astNode))
{
TermData = new VariableTerm(astNode.Name);
}
else
{
TermData = new ConstantTerm(astNode.Name);
}
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(NumericOpAstNode astNode)
{
MetricExpressions arguments = new MetricExpressions();
astNode.Arguments.ForEach(arg => arguments.Add(MasterExporter.ToMetricExpression(arg)));
switch (astNode.Operator)
{
case Traits.NumericOperator.PLUS:
{
ExpressionData = new MetricPlus(arguments);
break;
}
case Traits.NumericOperator.MINUS:
{
if (arguments.Count == 1)
{
ExpressionData = new MetricUnaryMinus(arguments[0]);
}
else
{
ExpressionData = new MetricMinus(arguments[0], arguments[1]);
}
break;
}
case Traits.NumericOperator.MUL:
{
ExpressionData = new MetricMultiply(arguments);
break;
}
case Traits.NumericOperator.DIV:
{
ExpressionData = new MetricDivide(arguments[0], arguments[1]);
break;
}
default:
{
Debug.Assert(false);
break;
}
}
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(ProblemMetricAstNode astNode)
{
ProblemData.Metric = new Metric(astNode.OptimizationSpecifier, MasterExporter.ToMetricExpression(astNode.MetricExpression));
}
/// <summary>
/// Loads a PDDL domain from the given input file. Does not include an input data validation.
/// </summary>
/// <param name="domainFilePath">PDDL domain input file.</param>
/// <returns>PDDL domain input data.</returns>
public static PDDL.Domain LoadDomain(string domainFilePath)
{
PDDL.Domain domain = MasterExporter.ToDomain(MasterParser.ParseAndCreateAst <DomainAstNode>(domainFilePath, new MasterGrammarDomain()));
domain.FilePath = domainFilePath;
return(domain);
}
/// <summary>
/// Loads a PDDL problem from the given input file. Does not include an input data validation.
/// </summary>
/// <param name="domainContext">Context of the corresponding domain.</param>
/// <param name="problemFilePath">PDDL problem input file.</param>
/// <returns>PDDL problem input data.</returns>
public static PDDL.Problem LoadProblem(PDDL.Domain domainContext, string problemFilePath)
{
PDDL.Problem problem = MasterExporter.ToProblem(domainContext, MasterParser.ParseAndCreateAst <ProblemAstNode>(problemFilePath, new MasterGrammarProblem()));
problem.FilePath = problemFilePath;
return(problem);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(DomainConstraintsAstNode astNode)
{
DomainData.Constraints = MasterExporter.ToConstraints(astNode.Expression);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(EqualsOpPEffectAstNode astNode)
{
EffectsData.Add(new EqualsEffect(MasterExporter.ToTerm(astNode.Term1), MasterExporter.ToTerm(astNode.Term2)));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(NotPEffectAstNode astNode)
{
EffectsData.Add(new NotEffect((AtomicFormulaEffect)MasterExporter.ToEffects(astNode.Argument)[0]));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(AndPEffectsAstNode astNode)
{
astNode.Arguments.ForEach(arg => EffectsData.AddRange(MasterExporter.ToEffects(arg)));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(ProblemInitAstNode astNode)
{
astNode.InitElemList.ForEach(initElem => ProblemData.Init.Add(MasterExporter.ToInitElement(initElem)));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(ForallCEffectAstNode astNode)
{
EffectsData.Add(new ForallEffect(MasterExporter.ToParameters(astNode.Parameters), MasterExporter.ToEffects(astNode.Effect)));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(WhenCEffectAstNode astNode)
{
EffectsData.Add(new WhenEffect(MasterExporter.ToExpression(astNode.Condition), ToPrimitiveEffects(MasterExporter.ToEffects(astNode.Effect))));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(AssignTimedEffectAstNode astNode)
{
EffectsData.Add(new AssignTimedEffect(astNode.AssignOperator, (NumericFunction)MasterExporter.ToNumericExpression(astNode.Function), MasterExporter.ToTimedNumericExpression(astNode.Expression)));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(AtTimedEffectAstNode astNode)
{
EffectsData.Add(new AtTimedEffect(astNode.TimeSpecifier, ToPrimitiveEffects(MasterExporter.ToEffects(astNode.Effect))));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(WhenDaEffectAstNode astNode)
{
EffectsData.Add(new WhenDurativeEffect(MasterExporter.ToDurativeExpression(astNode.Condition), (TimedEffect)MasterExporter.ToDurativeEffects(astNode.Effect)[0]));
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(ProblemGoalAstNode astNode)
{
ProblemData.Goal = MasterExporter.ToGoal(astNode);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(ProblemConstraintsAstNode astNode)
{
ProblemData.Constraints = MasterExporter.ToConstraints(astNode.Expression);
}
