/// <summary>
/// Constructs the preference expression.
/// </summary>
/// <param name="preferenceNameId">Preference name ID.</param>
/// <param name="child">An argument of the expression.</param>
/// <param name="idManager">ID manager.</param>
public PreferenceExpression(int preferenceNameId, IExpression child, IdManager idManager)
{
PreferenceNameId = preferenceNameId;
Child = child;
IdManager = idManager;
}
/// <summary>
/// Constructs the object from the input data.
/// </summary>
/// <param name="inputData">Operator effects input data.</param>
/// <param name="operatorPreconditions">Operator preconditions.</param>
/// <param name="idManager">ID manager.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public Effects(InputData.PDDL.Effects inputData, Conditions operatorPreconditions, IdManager idManager, EvaluationManager evaluationManager)
{
EffectsBuilder effectsBuilder = new EffectsBuilder(idManager);
inputData.ForEach(inputEffect => Add(effectsBuilder.Build(inputEffect)));
EffectsApplier = new Lazy <EffectsApplier>(() => new EffectsApplier(evaluationManager));
EffectsRelevanceConditionsEvaluator = new Lazy <EffectsRelevanceConditionsEvaluator>(() => new EffectsRelevanceConditionsEvaluator(this, evaluationManager.GroundingManager));
EffectsRelevanceRelativeStateEvaluator = new Lazy <EffectsRelevanceRelativeStateEvaluator>(() => new EffectsRelevanceRelativeStateEvaluator(this, evaluationManager.GroundingManager));
EffectsBackwardsConditionsApplier = new Lazy <EffectsBackwardsConditionsApplier>(() => new EffectsBackwardsConditionsApplier(operatorPreconditions, this, evaluationManager));
EffectsBackwardsRelativeStateApplier = new Lazy <EffectsBackwardsRelativeStateApplier>(() => new EffectsBackwardsRelativeStateApplier(operatorPreconditions, this, evaluationManager));
EffectsResultAtomsCollector = new Lazy <EffectsResultAtomsCollector>(() => new EffectsResultAtomsCollector(this, evaluationManager.GroundingManager));
}
/// <summary>
/// Constructs the expressions builder.
/// </summary>
/// <param name="idManager">ID manager.</param>
public ExpressionsBuilder(IdManager idManager)
{
IdManager = idManager;
TermsBuilder = new Lazy <TermsBuilder>(() => new TermsBuilder(IdManager));
}
/// <summary>
/// Constructs the object from the input data.
/// </summary>
/// <param name="actions">PDDL actions definition.</param>
/// <param name="idManager">ID manager.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public LiftedOperators(InputData.PDDL.Actions actions, IdManager idManager, EvaluationManager evaluationManager)
{
actions.ForEach(action => Add(new LiftedOperator(action, idManager, evaluationManager)));
}
/// <summary>
/// Constructs an empty state.
/// </summary>
/// <param name="idManager">ID manager.</param>
public State(IdManager idManager)
{
IdManager = idManager;
}
/// <summary>
/// Constructs the grounding object.
/// </summary>
/// <param name="idManager">ID manager.</param>
public TermsGrounder(IdManager idManager)
{
IdManager = idManager;
}
/// <summary>
/// Constructs the literal from the given expression.
/// </summary>
/// <param name="predicateAtom">Source predicate expression atom.</param>
/// <param name="isNegated">Is the literal negated?</param>
/// <param name="idManager">ID manager.</param>
public PredicateLiteralCNF(IAtom predicateAtom, bool isNegated, IdManager idManager)
{
PredicateAtom = predicateAtom;
IsNegated = isNegated;
IdManager = idManager;
}
/// <summary>
/// Constructs the object from the input data.
/// </summary>
/// <param name="inputData">Input data of the planning problem.</param>
/// <param name="parameters">Parameters of the lifted arguments (null if fully grounded).</param>
/// <param name="idManager">ID manager.</param>
/// <param name="evaluationManager">Evaluation manager.</param>
public Conditions(List <InputData.PDDL.Expression> inputData, Parameters parameters, IdManager idManager, EvaluationManager evaluationManager) : this(evaluationManager)
{
ExpressionsBuilder expressionsBuilder = new ExpressionsBuilder(idManager);
inputData.ForEach(inputExpression => Add(expressionsBuilder.Build(inputExpression)));
if (parameters != null)
{
Parameters = DetermineUsedParameters(parameters);
}
}
/// <summary>
/// Constructs the atom factory.
/// </summary>
/// <param name="idManager">ID manager.</param>
public PrimitivesFactory(IdManager idManager)
{
IdManager = idManager;
}
/// <summary>
/// Constructs the literal from the given expression.
/// </summary>
/// <param name="expression">Source expression.</param>
/// <param name="isNegated">Is the literal negated?</param>
public PredicateLiteralCNF(PredicateExpression expression, bool isNegated)
{
PredicateAtom = expression.PredicateAtom;
IsNegated = isNegated;
IdManager = expression.IdManager;
}
/// <summary>
/// Constructs the initial state data builder.
/// </summary>
/// <param name="idManager">ID manager.</param>
public InitialStateDataBuilder(IdManager idManager)
{
IdManager = idManager;
}
/// <summary>
/// Construct the parameter.
/// </summary>
/// <param name="parameterNameId">Parameter name ID.</param>
/// <param name="typeNamesIDs">Type names IDs.</param>
/// <param name="idManager">ID manager.</param>
public Parameter(int parameterNameId, ICollection <int> typeNamesIDs, IdManager idManager)
{
ParameterNameId = parameterNameId;
TypeNamesIDs = typeNamesIDs;
IdManager = idManager;
}
/// <summary>
/// Constructs the state from the specified data.
/// </summary>
/// <param name="predicates">Predicates of the state.</param>
/// <param name="numericFunctions">Numeric function values.</param>
/// <param name="objectFunctions">Object function values.</param>
/// <param name="idManager">ID manager.</param>
public State(HashSet <IAtom> predicates, Dictionary <IAtom, double> numericFunctions, Dictionary <IAtom, int> objectFunctions, IdManager idManager) : this(idManager)
{
Predicates = predicates;
NumericFunctions = numericFunctions;
ObjectFunctions = objectFunctions;
}
/// <summary>
/// Constructs an empty relative state.
/// </summary>
/// <param name="idManager">ID manager.</param>
public RelativeState(IdManager idManager) : base(idManager)
{
}
/// <summary>
/// Constructs the effects builder.
/// </summary>
/// <param name="idManager">ID manager.</param>
public EffectsBuilder(IdManager idManager)
{
IdManager = idManager;
TermsBuilder = new Lazy <TermsBuilder>(() => new TermsBuilder(IdManager));
}
/// <summary>
/// Constructs the relative state from the specified data.
/// </summary>
/// <param name="predicates">Predicates of the state.</param>
/// <param name="negatedPredicates">Negated predicates of the state.</param>
/// <param name="numericFunctions">Numeric function values.</param>
/// <param name="objectFunctions">Object function values.</param>
/// <param name="idManager">ID manager.</param>
public RelativeState(HashSet <IAtom> predicates, HashSet <IAtom> negatedPredicates, Dictionary <IAtom, double> numericFunctions, Dictionary <IAtom, int> objectFunctions, IdManager idManager)
: base(predicates, numericFunctions, objectFunctions, idManager)
{
NegatedPredicates = negatedPredicates;
}
/// <summary>
/// Constructs the expressions grounder.
/// </summary>
/// <param name="termsGrounder">Terms grounder.</param>
/// <param name="numericExpressionsGrounder">Numeric expressions grounder.</param>
/// <param name="idManager">ID manager.</param>
public ExpressionsGrounder(Lazy <TermsGrounder> termsGrounder, Lazy <NumericExpressionsGrounder> numericExpressionsGrounder, IdManager idManager)
{
TermsGrounder = termsGrounder;
NumericExpressionsGrounder = numericExpressionsGrounder;
IdManager = idManager;
}
/// <summary>
/// Constructs the terms builder.
/// </summary>
/// <param name="idManager">ID manager.</param>
public TermsBuilder(IdManager idManager)
{
IdManager = idManager;
}
/// <summary>
/// Constructs the predicate expression.
/// </summary>
/// <param name="predicateAtom">Predicate atom.</param>
/// <param name="idManager">ID manager.</param>
public PredicateExpression(IAtom predicateAtom, IdManager idManager)
{
PredicateAtom = predicateAtom;
IdManager = idManager;
}