pstlab / PLATINUm

public class PlanRefinementResolver extends Resolver<DomainComponent> {

	private boolean load;

	private double expansionCost;

	private double unificationCost;

	/**

	 * 

	 */

	protected PlanRefinementResolver() {

		super(ResolverType.PLAN_REFINEMENT.getLabel(), 

				ResolverType.PLAN_REFINEMENT.getFlawTypes());

		// flag to load parameters when it is necessary

		this.load = false;

	}

	/**

	 * 

	 */

	private void load() {

		// get deliberative property file

		FilePropertyReader properties = new FilePropertyReader(

				FRAMEWORK_HOME + FilePropertyReader.DEFAULT_DELIBERATIVE_PROPERTY);

		// read weights

		this.expansionCost = Double.parseDouble(properties.getProperty("expansion-cost"));

		this.unificationCost = Double.parseDouble(properties.getProperty("unification-cost"));

		// set load flag

		this.load = true;

	}

	/**

	 * 

	 */

	protected List<Flaw> doFindFlaws() {

		// check load parameters

		if (!this.load) {

			this.load();

		}

		// list of goals

		List<Flaw> flaws = new ArrayList<>();

		// check pending decisions

		for (Decision decision : this.component.getPendingDecisions()) {

			// add sub-goal

			Goal goal = new Goal(FLAW_COUNTER.getAndIncrement(), this.component, decision);

			// check if external component

			if (decision.getComponent().isExternal()) {

				// set mandatory unification

				goal.setMandatoryUnification();

			}

			// add goal to flaws

			flaws.add(goal);

		}

		// get flaws

		return flaws;

	}

	/**

	 * 

	 */

	protected void doComputeFlawSolutions(Flaw flaw) 

			throws UnsolvableFlawException {

		// get goal

		Goal goal = (Goal) flaw;

		// check solving information

		if (!goal.isMandatoryExpansion()) {

			// compute unification solutions

			this.doComputeUnificationSolutions(goal);

		}

		// check solving information

		if (!goal.isMandatoryUnification()) {

			// compute expansion solutions

			this.doComputeExpansionSolutions(goal);

		}

		// check if solvable

		if (!goal.isSolvable()) {

			// simply throw exception

			throw new UnsolvableFlawException("Unsolvable flaw found on component " + this.component.getName() + ":"

					+ "\n" + flaw + "\n");

		}

	}

	/**

	 * 

	 * @param solution

	 * @throws Exception

	 */

	@Override

	protected void doApply(FlawSolution solution) 

			throws FlawSolutionApplicationException 

	{

		// get goal justification

		GoalJustification just = (GoalJustification) solution;

		// check type 

		switch (just.getJustificationType()) 

		{

			// expansion step

			case EXPANSION : {

				// apply solution

				this.doApplyExpansion((GoalExpansion) just);

			}

			break;

			// unification step

			case UNIFICATION : {

				// apply solution

				this.doApplyUnification((GoalUnification) just);

			}

			break;

		}

	}

	/**

	 * 

	 */

	@Override

	protected void doRestore(FlawSolution solution) 

			throws DecisionPropagationException, RelationPropagationException 

	{

		// get goal justification

		GoalJustification just = (GoalJustification) solution;

		// check if unification 

		if (just.getJustificationType().equals(JustificationType.UNIFICATION)) {

			// restore unification

			this.doRestoreUnification((GoalUnification) just);

		}

		else {

			// "standard" way of restoring a flaw solution

			super.doRestore(solution);

		}

	}

	/**

	 * 

	 * @param solution

	 * @throws RelationPropagationException

	 */

			throws RelationPropagationException {

		// restore relation translation

		for (Relation rel : solution.getTranslatedReferenceGoalRelations()) {

			// check relation category

			if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT)) {

				// replace reference

				rel.setReference(solution.getUnificationDecision());

			}

			if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT)) {

				// check relation type

				switch (rel.getType()) {

					// bind parameter

					case BIND_PARAMETER: 

					{

						// the goal can be only the reference of the relation

						ParameterRelation pRel = (ParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = pRel.getReferenceParameterLabel();

						// get label index

						int refParameterIndex = pRel.getReference().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						pRel.setReference(solution.getUnificationDecision());

						// update reference label of the relation 

						pRel.setReferenceParameterLabel(label);

					}

					break;

					case EQUAL_PARAMETER : 

					{

						// get parameter relation

						EqualParameterRelation eqRel = (EqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = eqRel.getReferenceParameterLabel();

						// get label index

						int refParameterIndex = eqRel.getReference().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						eqRel.setReference(solution.getUnificationDecision());

						// update reference label of the relation 

						eqRel.setReferenceParameterLabel(label);

					}

					break;

					case NOT_EQUAL_PARAMETER : 

					{

						// get parameter relation

						NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = neqRel.getReferenceParameterLabel();

						// get label index

						int refParameterIndex = neqRel.getReference().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						neqRel.setReference(solution.getUnificationDecision());

						// update reference label of the relation 

						neqRel.setReferenceParameterLabel(label);

					}

					break;

					default:

						// unknown parameter relation

				}

			}

		}

		// restore relation translation

		for (Relation rel : solution.getTranslatedTargetGoalRelations()) {

			// check relation category

			if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT)) {

				// replace reference

				rel.setTarget(solution.getUnificationDecision());

			}

			if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT)) {

				// check relation type

				switch (rel.getType()) {

					case EQUAL_PARAMETER : 

					{

						// get parameter relation

						EqualParameterRelation eqRel = (EqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = eqRel.getTargetParameterLabel();

						// get label index

						int refParameterIndex = eqRel.getTarget().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						eqRel.setTarget(solution.getUnificationDecision());

						// update reference label of the relation 

						eqRel.setTargetParameterLabel(label);

					}

					break;

					case NOT_EQUAL_PARAMETER : 

					{

						// get parameter relation

						NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = neqRel.getTargetParameterLabel();

						// get label index

						int refParameterIndex = neqRel.getTarget().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						neqRel.setTarget(solution.getUnificationDecision());

						// update reference label of the relation 

						neqRel.setTargetParameterLabel(label);

					}

					break;

					default:

						// unknown parameter relation

				}

			}

		}

		// list of committed parameter constraints

		Set<Relation> committed = new HashSet<>();

		try	

		{

			// get goal component

			DomainComponent gComp = solution.getGoalDecision().getComponent();

			// remove original goal: PENDING -> SILENT

			gComp.free(solution.getGoalDecision());

			// activate translated relations

			for (Relation rel : solution.getActivatedRelations()) 

			{

				// check if can be activated

				if (rel.getReference().getComponent().activate(rel)) {

					// add relation to the committed list

					committed.add(rel);

				}

			}

			// check consistency

//			this.tdb.verify();

			this.pdb.verify();

		} catch (RelationPropagationException | ConsistencyCheckException ex) {

			// get goal component

			DomainComponent gComp = solution.getGoalDecision().getComponent();

			// restore goal: SILENT -> PENDING

			gComp.restore(solution.getGoalDecision());

			// deactivate committed relations

			for (Relation rel : committed) {

				// get reference component

				DomainComponent refComp = rel.getReference().getComponent();

				refComp.deactivate(rel);

			}

			// translated back relations

			for (Relation rel : solution.getTranslatedReferenceGoalRelations()) {

				// check category

				if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT)) {

					// get parameter relation

					ParameterRelation pRel = (ParameterRelation) rel;

					// get relation reference parameter label

					String refParamLabel = pRel.getReferenceParameterLabel();

					// get label index

					int pIndex = pRel.getReference().getParameterIndexByLabel(refParamLabel);

					// get goal decision parameter label

					String label = solution.getGoalDecision().getParameterLabelByIndex(pIndex);

					// update relation

					pRel.setReference(solution.getGoalDecision());

					pRel.setReferenceParameterLabel(label);

				}

				if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT)) {

					// update relation

					rel.setReference(solution.getGoalDecision());

				}

			}

			// translated back parameter relations

			for (Relation rel : solution.getTranslatedTargetGoalRelations())

			{

				// check relation category 

				if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT))

				{

					// check relation

					switch (rel.getType())

					{

						case EQUAL_PARAMETER : 

						{

							// get equal relation

							EqualParameterRelation eqRel = (EqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = eqRel.getTargetParameterLabel();

							// get label index

							int pIndex = eqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = solution.getGoalDecision().getParameterLabelByIndex(pIndex);

							// update relation

							eqRel.setTarget(solution.getGoalDecision());

							eqRel.setTargetParameterLabel(label);

						}

						break;

						case NOT_EQUAL_PARAMETER : 

						{

							// get equal relation

							NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = neqRel.getTargetParameterLabel();

							// get label index

							int pIndex = neqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = solution.getGoalDecision().getParameterLabelByIndex(pIndex);

							// update relation

							neqRel.setTarget(solution.getGoalDecision());

							neqRel.setTargetParameterLabel(label);

						}

						break;

						default:

							// unknown parameter relation

					}

				}

				// check temporal relation

				if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT))

				{

					// update relation

					rel.setTarget(solution.getGoalDecision());

				}

			}

			// not feasible solution

			throw new RelationPropagationException(ex.getMessage());

		}

	}

	/**

	 * 

	 */

	@Override

	protected void doRetract(FlawSolution solution) 

	{

		// check solution type

		GoalJustification justif = (GoalJustification) solution;

		// check if unification solution

		if (justif.getJustificationType().equals(JustificationType.UNIFICATION)) {

			// special management of unification

			this.doRetractUnification((GoalUnification) solution);

		}

		else {

			// "standard" management of flaw solution

			super.doRetract(solution);

		}

	}

	/**

	 * 

	 * @param goal

	 */

		// get goal component

		DomainComponent gComp = goal.getComponent();

		// list of goal unifications found

		List<GoalUnification> unifications = new ArrayList<>();

		// search active decisions that can be unified with the goal

		for (Decision unif : gComp.getActiveDecisions()) {

			// check predicate and temporal unification

			if (this.isPredicateUnificationFeasible(goal.getDecision(), unif) && 

					this.isTemporalUnificationFeasible(goal.getDecision(), unif)) {

				// possible unification found

				GoalUnification unification = new GoalUnification(goal, unif, this.unificationCost);

				// add unifications

				unifications.add(unification);

				info("Feasible unification found:\n"

						+ "- planning goal: " + goal + "\n"

						+ "- unification decision: " + unification + "\n");

			}

			else {

				// unification not feasible

				debug("No feasible unification:\n"

						+ "- planning goal: " + goal + "\n"

						+ "- decision : \"" + unif + "\"\n");

			}

		}

		// add unifications as goal solutions

		Collections.shuffle(unifications);

		for (GoalUnification unif : unifications) {

			goal.addSolution(unif);

		}

	}

	/**

	 * 

	 * @param goal

	 * @param decision

	 * @return

	 */

	{

		// feasibility flag

		boolean feasible = true;

		// first check if the decisions refer to the same values

		if (!decision.getValue().equals(goal.getValue()) && 

				decision.getComponent().equals(goal.getComponent())) {

			// not feasible unification

			feasible = false;

			debug("Not feasible predicate unification:\n"

					+ "- planning goal: " + goal + "\n"

					+ "- unification decision: " + decision + "\n"); 

		}

		else 

		{

			// list of committed parameter constraints

			Set<Relation> committed = new HashSet<>();

			// list of translated parameter relations - reference

			Set<ParameterRelation> translatedReferenceGoalRelations = new HashSet<>();

			// list of translated parameter relations - target

			Set<ParameterRelation> translatedTargetGoalRelations = new HashSet<>();

			// get goal component

			DomainComponent goalComp = goal.getComponent();

			// get all (pending) relation concerning the goal decision

			Set<Relation> pending = goalComp.getRelations(goal);

			// check relations

			for (Relation rel : pending)

			{

				// check parameter constraint type

				if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT))

				{

					// check relation type

					switch (rel.getType())

					{

						// bind parameter

						case BIND_PARAMETER: 

						{

							// the goal can be only the reference of the relation

							ParameterRelation pRel = (ParameterRelation) rel;

							// get relation reference parameter label

							String refParamLabel = pRel.getReferenceParameterLabel();

							// get label index

							int refParameterIndex = pRel.getReference().getParameterIndexByLabel(refParamLabel);

							// get unification decision parameter label

							String label = decision.getParameterLabelByIndex(refParameterIndex);

							// update reference decision 

							pRel.setReference(decision);

							// update reference label of the relation 

							pRel.setReferenceParameterLabel(label);

							// add relation to the list of translated ones

							translatedReferenceGoalRelations.add(pRel);

						}

						break;

						case EQUAL_PARAMETER : 

						{

							// get parameter relation

							EqualParameterRelation eqRel = (EqualParameterRelation) rel;

							// check if the goal is the reference or the parameter constraint 

							if (eqRel.getReference().equals(goal))

							{

								// get relation reference parameter label

								String refParamLabel = eqRel.getReferenceParameterLabel();

								// get label index

								int refParameterIndex = eqRel.getReference().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								eqRel.setReference(decision);

								// update reference label of the relation 

								eqRel.setReferenceParameterLabel(label);

								// add relation to the list of translated ones

								translatedReferenceGoalRelations.add(eqRel);

							}

							else // the goal is the target of the relation 

							{

								// get relation reference parameter label

								String refParamLabel = eqRel.getTargetParameterLabel();

								// get label index

								int refParameterIndex = eqRel.getTarget().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								eqRel.setTarget(decision);

								// update reference label of the relation 

								eqRel.setTargetParameterLabel(label);

								// add relation to the list of translated ones

								translatedTargetGoalRelations.add(eqRel);

							}

						}

						break;

						case NOT_EQUAL_PARAMETER : 

						{

							// get parameter relation

							NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

							// check if the goal is the reference or the parameter constraint 

							if (neqRel.getReference().equals(goal))

							{

								// get relation reference parameter label

								String refParamLabel = neqRel.getReferenceParameterLabel();

								// get label index

								int refParameterIndex = neqRel.getReference().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								neqRel.setReference(decision);

								// update reference label of the relation 

								neqRel.setReferenceParameterLabel(label);

								// add relation to the list of translated ones

								translatedReferenceGoalRelations.add(neqRel);

							}

							else // the goal is the target of the relation 

							{

								// get relation reference parameter label

								String refParamLabel = neqRel.getTargetParameterLabel();

								// get label index

								int refParameterIndex = neqRel.getTarget().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								neqRel.setTarget(decision);

								// update reference label of the relation 

								neqRel.setTargetParameterLabel(label);

								// add relation to the list of translated ones

								translatedTargetGoalRelations.add(neqRel);

							}

						}

						break;

						default:

							// unknown parameter relation

					}

				}

			}

			try

			{

				// activate translated relations

				for (Relation rel : translatedReferenceGoalRelations) {

					// check if can be activated

					if (rel.getReference().getComponent().activate(rel)) {

						// add relation to the committed list

						committed.add(rel);

					}

				}

				// activate translated relations

				for (Relation rel : translatedTargetGoalRelations) {

					// check if can be activated

					if (rel.getReference().getComponent().activate(rel)) {

						// add relation to the committed list

						committed.add(rel);

					}

				}

				// check parameter of the plan

				this.pdb.verify();

			}

			catch (ConsistencyCheckException | RelationPropagationException ex) {

				// not feasible 

				feasible = false;

				// not feasible unification

				debug("Not feasible predicate unification:\n"

						+ "- planning goal: " + goal + "\n"

						+ "- unification decision: " + decision + "\n");

			}

			finally 

			{

				// check committed relations

				for (Relation rel : committed) {

					// deactivate relation

					rel.getReference().getComponent().deactivate(rel);

				}

				// translated back parameter relations

				for (ParameterRelation rel : translatedReferenceGoalRelations)

				{

					// get relation reference parameter label

					String refParamLabel = rel.getReferenceParameterLabel();

					// get label index

					int pIndex = rel.getReference().getParameterIndexByLabel(refParamLabel);

					// get goal decision parameter label

					String label = goal.getParameterLabelByIndex(pIndex);

					// update relation

					rel.setReference(goal);

					rel.setReferenceParameterLabel(label);

				}

				// translated back parameter relations

				for (ParameterRelation rel : translatedTargetGoalRelations)

				{

					// check relation

					switch (rel.getType())

					{

						case EQUAL_PARAMETER : 

						{

							// get equal relation

							EqualParameterRelation eqRel = (EqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = eqRel.getTargetParameterLabel();

							// get label index

							int pIndex = eqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = goal.getParameterLabelByIndex(pIndex);

							// update relation

							eqRel.setTarget(goal);

							eqRel.setTargetParameterLabel(label);

						}

						break;

						case NOT_EQUAL_PARAMETER : 

						{

							// get equal relation

							NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = neqRel.getTargetParameterLabel();

							// get label index

							int pIndex = neqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = goal.getParameterLabelByIndex(pIndex);

							// update relation

							neqRel.setTarget(goal);

							neqRel.setTargetParameterLabel(label);

						}

						break;

						default:

							// unknown parameter relation

					}

				}

			}

		}

		// get feasibility flag

		return feasible;

	}

	/**

	 * 

	 * @param goal

	 * @param decision

	 * @return

	 */

	{

		// feasibility flag

		boolean feasible = true;

		// list of translated relations

		Set<Relation> translated = new HashSet<>();

		// list of committed relations

		Set<Relation> committed = new HashSet<>();

		// get goal component 

		DomainComponent gComp = goal.getComponent();

		// get all (pending) relations associated to the goal 

		Set<Relation> pRels = gComp.getRelations(goal);

		// translate relations

		for (Relation pRel : pRels)

		{

			// focus on temporal relations only 

			if (pRel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT))

			{

				// check relation reference

				if (pRel.getReference().equals(goal)) {

					// replace reference

					pRel.setReference(decision);

					// add translated relation

					translated.add(pRel);

				}

				// check relation target

				if (pRel.getTarget().equals(goal)) {

					// replace target

					pRel.setTarget(decision);

					// add translated relation

					translated.add(pRel);

				}

			}

		}

		try

		{

			// check translated relation and activate them if possible

			for (Relation tRel : translated) {

				// activate relation

				if (tRel.getReference().getComponent().activate(tRel)) {

					// add relation to committed list

					committed.add(tRel);

				}

			}

			// check temporal consistency after activated relations

//			this.tdb.verify();

		}

		catch (RelationPropagationException ex) {

			// not feasible unification 

			feasible = false;

			// not feasible unification

			debug("Not feasible temporal unification:\n"

					+ "- planning goal: " + goal + "\n"

					+ "- unification decision: " + decision + "\n");

		}

		finally 

		{

			// deactivate relations

			for (Relation rel : committed) {

				// deactivate relation

				rel.getReference().getComponent().deactivate(rel);

			}

			// translate back relations

			for (Relation rel : translated) {

				// check reference 

				if (rel.getReference().equals(decision)) {

					// replace reference

					rel.setReference(goal);

				}

				// check target

				if (rel.getTarget().equals(decision)) {

					// replace target

					rel.setTarget(goal);

				}

			}

		}

		// get feasibility flag

		return feasible;

	}

	/**

	 * 

	 * @param goal

	 */

	private void doComputeExpansionSolutions(Goal goal) {

		// get component

		DomainComponent gComp = goal.getComponent();

		// set of activated relations

		List<Relation> rels = new ArrayList<>();

		// list of goal expansions

		List<GoalExpansion> expansions = new ArrayList<>();

		try {

			// activate the goal and get activated relations

			rels.addAll(gComp.activate(goal.getDecision()));

			// check temporal and parameter consistency

//			this.tdb.verify();

			this.pdb.verify();

			// check rules

			List<SynchronizationRule> rules = this.component.getSynchronizationRules(goal.getDecision().getValue());

				// the goal can be justified without applying rules

				GoalExpansion expansion = new GoalExpansion(goal, this.expansionCost);

				// add expansion 

				expansions.add(expansion);

				// print debug message

				debug("Simple goal found no synchronization is triggered after expansion:\n"

						+ "- planning goal: " + goal.getDecision() + "\n");

			} else {

				// can do expansion

				for (SynchronizationRule rule : rules) {

					// expansion solution

					GoalExpansion expansion = new GoalExpansion(goal, rule, this.expansionCost);

					// add expansion

					expansions.add(expansion);

					// print debug message

					debug("Complex goal found:\n"

							+ "- planning goal: " + goal.getDecision() + "\n"

							+ "- synchronization rule: " + rule + "\n");

				}

			}

			// add all expansions found as solutions

			Collections.shuffle(expansions);

			for (GoalExpansion exp : expansions) {

				goal.addSolution(exp);

			}

		} catch (DecisionPropagationException | ConsistencyCheckException  ex) {

			// not feasible goal expansion

			warning(ex.getMessage());

		} finally {

			// deactivate relations if any

			for (Relation rel : rels) {

				gComp.deactivate(rel);

			}

			// deactivate goal decision

			gComp.deactivate(goal.getDecision());

		}

	}

	/**

	 * 

	 * @param unification

	 * @throws Exception

	 */

			throws FlawSolutionApplicationException {

		// get original goal

		Decision goal = unification.getGoalDecision();

		// get all (pending) relations concerning the planning goal

		DomainComponent goalComp = goal.getComponent();

		// list of committed parameter constraints

		Set<Relation> committed = new HashSet<>();

		// list of translated parameter relations - reference

		Set<Relation> translatedReferenceGoalRelations = new HashSet<>();

		// list of translated parameter relations - target

		Set<Relation> translatedTargetGoalRelations = new HashSet<>();

		// get pending relations associated to the goal

		Set<Relation> gRels = goalComp.getRelations(goal);

		// translate pending relations by replacing goal's information with unification decision's information

		for (Relation rel : gRels) {

			// check relation category

			if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT)) {

				// check relation reference

				if (rel.getReference().equals(goal)) {

					// replace reference 

					rel.setReference(unification.getUnificationDecision());

					// add relation to the list

					translatedReferenceGoalRelations.add(rel);

				}

				// check relation target

				if (rel.getTarget().equals(goal)) {

					// replace target

					rel.setTarget(unification.getUnificationDecision());

					// add relation to the list

					translatedTargetGoalRelations.add(rel);

				}

			}

			if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT))

			{

				// check relation type

				switch (rel.getType())

				{

					// bind parameter

					case BIND_PARAMETER: 

					{

						// the goal can be only the reference of the relation

						ParameterRelation pRel = (ParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = pRel.getReferenceParameterLabel();

						// get label index

						int refParameterIndex = pRel.getReference().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = unification.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);