pstlab / PLATINUm

import java.io.IOException;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.antlr.runtime.ANTLRFileStream;

import org.antlr.runtime.CharStream;

import org.antlr.runtime.CommonTokenStream;

import org.antlr.runtime.RecognitionException;

import org.antlr.runtime.tree.Tree;

import it.cnr.istc.pst.platinum.ai.framework.domain.PlanDataBaseBuilder;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.ComponentValue;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.DomainComponent;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.DomainComponentType;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.PlanDataBase;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.pdb.SynchronizationRule;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.pdb.TokenVariable;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.resource.discrete.DiscreteResource;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.resource.discrete.RequirementResourceValue;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.resource.reservoir.ReservoirResource;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.sv.StateVariable;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.sv.StateVariableValue;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.sv.Transition;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.ex.DomainComponentNotFoundException;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.ex.SynchronizationCycleException;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.problem.Problem;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.problem.ProblemFact;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.problem.ProblemFluent;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.problem.ProblemGoal;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.RelationType;

import it.cnr.istc.pst.platinum.ai.framework.parameter.lang.EnumerationParameterDomain;

import it.cnr.istc.pst.platinum.ai.framework.parameter.lang.NumericParameterDomain;

import it.cnr.istc.pst.platinum.ai.framework.parameter.lang.ParameterDomain;

import it.cnr.istc.pst.platinum.ai.framework.parameter.lang.ParameterDomainType;

import it.cnr.istc.pst.platinum.ai.framework.parameter.lang.constraints.ParameterConstraintType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.DomainCompiler;

import it.cnr.istc.pst.platinum.ai.lang.ddl.DomainCompilerType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLComponent;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLComponentDecision;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLComponentType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLConsumableResourceComponentDecision;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLConsumableResourceComponentType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLDomain;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLEnumerationParameterConstraint;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLEnumerationParameterConstraint.DDLEnumerationParameterConstraintType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLEnumerationParameterType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLInstantiatedComponentDecision;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLNumericParameterConstraint;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLNumericParameterConstraint.DDLNumericParameterConstraintType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLNumericParameterType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLParameterConstraint;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLParameterType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLProblem;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLRenewableResourceComponentDecision;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLRenewableResourceComponentType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLSimpleGroundStateVariableComponentDecision;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLSingletonStateVariableComponentDecision;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLSingletonStateVariableComponentDecisionType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLSingletonStateVariableComponentType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLSingletonStateVariableTransitionConstraint;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLSynchronization;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLTemporalRelation;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLTemporalRelationType;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLTimeline;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.DDLTimelineSynchronization;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.ddl3Lexer;

import it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser.ddl3Parser;

/**

 * 

 * @author anacleto

 *

 */

public class DDLv3Compiler extends DomainCompiler 

{

	private long origin;

	private long horizon;

	protected DDLDomain ddl_domain;

    protected DDLProblem ddl_problem;

	/**

	 * 

	 * @param ddlFilePath

	 * @param pdlFilePath

	 */

	protected DDLv3Compiler(String ddlFilePath, String pdlFilePath) {

		super(DomainCompilerType.DDLv3, ddlFilePath, pdlFilePath);

	}

	/**

	 * 

	 * @param ddlFilePath

	 */

	protected DDLv3Compiler(String ddlFilePath) {

		super(DomainCompilerType.DDLv3, ddlFilePath);

	}

	/**

     * 

     * @return

     * @throws SynchronizationCycleException

     */

	@Override

    public PlanDataBase compileDomain() 

    		throws SynchronizationCycleException 

	{

		try 

		{

    		// parse domain

    		this.doParseDDLFile(this.ddlFilePath);

    	} 

    	catch (IOException | RecognitionException ex) {

    	}

		// actually compile domain

    	return this.doCompileDomain();

    }

    /**

     * 

     */

	@Override

    public Problem compileProblem(PlanDataBase pdb) 

	{

		try 

		{

    		// parse problem

	    	this.doParseDDLFile(this.pdlFilePath);

    	} 

    	catch (IOException | RecognitionException ex) {

    	}

    	// actually compile problem

    	return this.doCompileProblem(pdb);

    }

    /**

     * 

     * @param ddlFilePath

     * @throws IOException

     * @throws RecognitionException

     */

    private void doParseDDLFile(String ddlFilePath) 

    		throws IOException, RecognitionException 

    {

    	// parse domain

    	CharStream dcs = new ANTLRFileStream(ddlFilePath);

		ddl3Lexer lexer = new ddl3Lexer(dcs);

		CommonTokenStream tokens = new CommonTokenStream();

		tokens.setTokenSource(lexer);

		ddl3Parser parser = new ddl3Parser(tokens);

		final ddl3Parser.ddl_return parserResult = parser.ddl();

		Tree ddl = (Tree) parserResult.getTree();

		if (ddl.getChild(0) instanceof DDLDomain) 

		{

		    this.ddl_domain = (DDLDomain) ddl.getChild(0);

		    this.ddl_domain.parse();

		    // parse problem specification

		    if (ddl.getChild(1) instanceof DDLProblem) 

		    {

				this.ddl_problem = (DDLProblem) ddl.getChild(1);

				this.ddl_problem.parse();

		    } 

		    else {

		    	// error while parsing

		    	this.ddl_problem = null;

		    }

		} 

		else 

		{

		    this.ddl_problem = (DDLProblem) ddl.getChild(0);

		    this.ddl_problem.parse();

		    this.ddl_domain = null;

		}

    }

	/**

	 * 

	 */

	private PlanDataBase doCompileDomain() 

			throws SynchronizationCycleException 

	{

		// get parameter

		this.origin = this.ddl_domain.getTemporalModule().getRange().getMin();

		this.horizon = this.ddl_domain.getTemporalModule().getRange().getMax();

		String name = this.ddl_domain.getName();

		// create plan data-base

		PlanDataBase pdb = PlanDataBaseBuilder.createAndSet(name, this.origin, this.horizon);

		// add parameter domain declaration

		this.addParameterDomains(pdb);

		// add data

		this.addComponents(pdb);

		// add synchronization rules

		this.addSynchronizationRules(pdb);

		// get created plan data-base

		return pdb;

	}

	/**

	 * 

	 */

	private Problem doCompileProblem(PlanDataBase pdb) {

		// create problem

		Problem problem = new Problem();

		// local cache

		Map<String, ProblemGoal> goals = new HashMap<>();

		Map<String, ProblemFluent> label2fluent = new HashMap<>();

		// check problem decisions

		for (DDLInstantiatedComponentDecision ddlDec : this.ddl_problem.getComponentDecisions().values()) {

			// get related component

			DomainComponent comp = pdb.getComponentByName(ddlDec.getComponent());

			// get related value

			ComponentValue val = comp.getValueByName(ddlDec.getComponentDecision().getName());

			// check if component is external

			if (comp.isExternal()) {

				// add observation

				ProblemFact fact = this.addObservationToProblem(problem, val, ddlDec);

				for (String label : fact.getParameterLabels()) {

					label2fluent.put(label, fact);

				}

			}

			else {

				// check type of decision

				if (ddlDec.getParameters().contains("fact")) {

					// add fact to problem

					ProblemFact fact = this.addFactToProblem(problem, val, ddlDec);

					for (String label : fact.getParameterLabels()) {

						label2fluent.put(label, fact);

					}

				}

				else if (ddlDec.getParameters().contains("goal")) {

					// add goal to problem

					ProblemGoal goal = this.addGoalToProblem(problem, val, ddlDec);

					goals.put(ddlDec.getId(), goal);

					for (String label : goal.getParameterLabels()) {

						label2fluent.put(label, goal);

					}

				}

				else {

				}

			}

		}

		// add constraints between goals

		for (DDLTemporalRelation ddlRel : this.ddl_problem.getTemporalRelations()) {

			// get related goals

			ProblemGoal reference = goals.get(ddlRel.getFrom());

			ProblemGoal target = goals.get(ddlRel.getTo());

			// add constraint between goals

			this.addBinaryGoal(problem, reference, target, ddlRel.getRelationType());

		}

		// add parameter constraints

		for (DDLParameterConstraint ddlRel : this.ddl_problem.getParameterConstraints()) {

			// check type

			switch (ddlRel.getConstraintType()) {

				// enumeration constraint

				case ENUMERATION : {

					// get enumeration

					DDLEnumerationParameterConstraint ddlpc = (DDLEnumerationParameterConstraint) ddlRel;

					// get related fluent

					ProblemFluent fluent = label2fluent.get(ddlpc.getLeftTerm());

					// check relation type

					if (ddlpc.getEnumerationConstraintType().equals(DDLEnumerationParameterConstraintType.NEQ)) {

					}

					// add binding parameter constraint

					problem.addBindingParameterConstraint(fluent, ddlpc.getLeftTerm(), ddlpc.getValue());

				}

				break;

				// numeric constraint

				case NUMERIC : {

					// get numeric

					DDLNumericParameterConstraint ddlpc = (DDLNumericParameterConstraint) ddlRel;

					// get reference

					ProblemFluent reference = label2fluent.get(ddlpc.getLeftTerm());

					String referenceLabel = ddlpc.getLeftTerm();

					// check if binary constraint

					if (ddlpc.getRightVariables() != null && ddlpc.getRightVariables().get(0) != null) {

						// get relation type

						RelationType relType;

						switch (ddlpc.getNumericConstraintType()) {

							case EQ : {

								// set relation type

								relType = RelationType.EQUAL_PARAMETER;

							}

							break;

							case NEQ : {

								// set relation type

								relType = RelationType.NOT_EQUAL_PARAMETER;

							}

							break;

							default : {

							}

						}

						// get targets

						for (String targetLabel : ddlpc.getRightVariables()) {

							// get target fluent

							ProblemFluent target = label2fluent.get(targetLabel);

							// create constraint

							problem.addParameterConstraint(relType, reference, referenceLabel, target, targetLabel);

						}

					}

					else {

						// check relation type

						if (ddlpc.getNumericConstraintType().equals(DDLNumericParameterConstraintType.NEQ)) {

						}

						// add constraint

						problem.addBindingParameterConstraint(reference, referenceLabel, Integer.toString(ddlpc.getRightCoefficients().get(0)));

					}

				}

				break;

			}

		}

		// get created problem

		return problem;

	}

	/**

	 * 

	 * @param problem

	 * @param val

	 * @param ddlDec

	 * @return

	 */

		// set start bound

		long[] start = new long[] {this.origin, this.horizon};

		// check start bounds

		if (ddlDec.getStart() != null) {

			start = new long[] {

				ddlDec.getStart().getMin(),

				ddlDec.getStart().getMax() > this.horizon ? 

						this.horizon : 

						ddlDec.getStart().getMax()

			};

		}

		// set end bound 

		long[] end = new long[] {this.origin, this.horizon};

		if (ddlDec.getEnd() != null) {

			end = new long[] {

					ddlDec.getEnd().getMin(),

					ddlDec.getEnd().getMax() > this.horizon ? 

							this.horizon : 

							ddlDec.getEnd().getMax()

				};

		}

		// parameter labels

		String[] labels = new String[] {};

		if (ddlDec.getComponentDecision() instanceof DDLSingletonStateVariableComponentDecision) {

			// get decision

			DDLSingletonStateVariableComponentDecision ddlSingleton = (DDLSingletonStateVariableComponentDecision) ddlDec.getComponentDecision();

			labels = ddlSingleton.getParameterNames().toArray(new String[ddlSingleton.getParameterNames().size()]);

		}

		// add goal

		return problem.addGoal(val, labels, start, end);

	}

	/**

	 * 

	 * @param problem

	 * @param val

	 * @param ddlDec

	 * @return

	 */

		// set start bound

		long[] start = new long[] {this.origin, this.horizon};

		// check start bounds

		if (ddlDec.getStart() != null) {

			start = new long[] {

				ddlDec.getStart().getMin(),

				ddlDec.getStart().getMax() > this.horizon ? 

						this.horizon : 

						ddlDec.getStart().getMax()

			};

		}

		// set end bound 

		long[] end = new long[] {this.origin, this.horizon};

		if (ddlDec.getEnd() != null) {

			end = new long[] {

					ddlDec.getEnd().getMin(),

					ddlDec.getEnd().getMax() > this.horizon ? 

							this.horizon : 

							ddlDec.getEnd().getMax()

				};

		}

		// parameter labels

		String[] labels = new String[] {};

		if (ddlDec.getComponentDecision() instanceof DDLSingletonStateVariableComponentDecision) {

			// get decision

			DDLSingletonStateVariableComponentDecision ddlSingleton = (DDLSingletonStateVariableComponentDecision) ddlDec.getComponentDecision();

			labels = ddlSingleton.getParameterNames().toArray(new String[ddlSingleton.getParameterNames().size()]);

		}

		// add a fact

		return problem.addFact(val, labels, start, end);

	}

	/**

	 * 

	 * @param problem

	 * @param val

	 * @param ddlDec

	 * @return

	 */

	private ProblemFact addObservationToProblem(Problem problem, ComponentValue val, DDLInstantiatedComponentDecision ddlDec) 

	{

		// set start bound

		long[] start = new long[] {this.origin, this.horizon};

		// check start bounds

		if (ddlDec.getStart() != null) {

			start = new long[] {

				ddlDec.getStart().getMin(),

				ddlDec.getStart().getMax() > this.horizon ? 

						this.horizon : 

						ddlDec.getStart().getMax()

			};

		}

		// set end bound 

		long[] end = new long[] {this.origin, this.horizon};

		if (ddlDec.getEnd() != null) {

			end = new long[] {

					ddlDec.getEnd().getMin(),

					ddlDec.getEnd().getMax() > this.horizon ? 

							this.horizon : 

							ddlDec.getEnd().getMax()

				};

		}

		// set duration bound

		long[] duration = new long[] {1, this.horizon};

		if (ddlDec.getDuration() != null) {

			duration = new long[] {

					ddlDec.getDuration().getMin(),

					ddlDec.getDuration().getMax() > this.horizon ? 

							this.horizon : 

							ddlDec.getDuration().getMax()

				};

		}

		// parameter labels

		String[] labels = new String[] {};

		if (ddlDec.getComponentDecision() instanceof DDLSingletonStateVariableComponentDecision) {

			// get decision

			DDLSingletonStateVariableComponentDecision ddlSingleton = (DDLSingletonStateVariableComponentDecision) ddlDec.getComponentDecision();

			labels = ddlSingleton.getParameterNames().toArray(new String[ddlSingleton.getParameterNames().size()]);

		}

		// add observation

		return problem.addObservation(val, labels, start, end, duration);

	}

	/**

	 * 

	 * @param problem

	 * @param reference

	 * @param target

	 * @param ddlRelType

	 */

		// check relation type

		if (ddlRelType.getText().equalsIgnoreCase("meets")) {

			// create meets constraint

			problem.addTemporalConstraint(RelationType.MEETS, reference, target, new long[][] {});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("met-by")) {

			// create met-by constraint

			problem.addTemporalConstraint(RelationType.MET_BY, reference, target, new long[][] {});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("during")) { 

			// create during constraint

			problem.addTemporalConstraint(RelationType.DURING, reference, target, 

				new long[][] {

					new long[] {

						ddlRelType.getFirstRange().getMin(),

						ddlRelType.getFirstRange().getMax() > this.horizon ? 

								this.horizon :

								ddlRelType.getFirstRange().getMax()

					},

					new long[] {

						ddlRelType.getSecondRange().getMin(),

						ddlRelType.getSecondRange().getMax() > this.horizon ? 

								this.horizon :

								ddlRelType.getSecondRange().getMax()

					}

				});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("equals")) {

			// create equals constraint

			problem.addTemporalConstraint(RelationType.EQUALS, reference, target, new long[][] {});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("contains")) {

			// create contains constraint

			problem.addTemporalConstraint(RelationType.CONTAINS, reference, target, 

				new long[][] {

					new long[] {

						ddlRelType.getFirstRange().getMin(),

						ddlRelType.getFirstRange().getMax() > this.horizon ? 

								this.horizon : 

								ddlRelType.getFirstRange().getMax()

					},

					new long[] {

						ddlRelType.getSecondRange().getMin(),

						ddlRelType.getSecondRange().getMax() > this.horizon ?

								this.horizon : 

								ddlRelType.getSecondRange().getMax()

					}

				});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("before")) {

			problem.addTemporalConstraint(RelationType.BEFORE, reference, target, 

				new long[][] {

					new long[] {

						ddlRelType.getFirstRange().getMin(),

						ddlRelType.getFirstRange().getMax() > this.horizon ? 

								this.horizon :

								ddlRelType.getFirstRange().getMax()

					}

				});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("after")) {

			problem.addTemporalConstraint(RelationType.AFTER, reference, target, 

					new long[][] {

						new long[] {

							ddlRelType.getFirstRange().getMin(),

							ddlRelType.getFirstRange().getMax() > this.horizon ? 

									this.horizon :

									ddlRelType.getFirstRange().getMax()

						}

					});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("start-start")) {

			problem.addTemporalConstraint(RelationType.START_START, reference, target, 

					new long[][] {

						new long[] {

								ddlRelType.getFirstRange().getMin(),

								ddlRelType.getFirstRange().getMax() > this.horizon ? 

										this.horizon : 

										ddlRelType.getFirstRange().getMax()

						}

			});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("end-end")) {

			problem.addTemporalConstraint(RelationType.END_END, reference, target, 

					new long[][] {

						new long[] {

								ddlRelType.getFirstRange().getMin(),

								ddlRelType.getFirstRange().getMax() > this.horizon ? 

										this.horizon : 

										ddlRelType.getFirstRange().getMax()

						}

			});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("starts-during")) {

			problem.addTemporalConstraint(RelationType.STARTS_DURING, reference, target, 

					new long[][] {

						new long[] {

							ddlRelType.getFirstRange().getMin(),

							ddlRelType.getFirstRange().getMax() > this.horizon ? 

									this.horizon :

									ddlRelType.getFirstRange().getMax()

						},

						new long[] {

							ddlRelType.getSecondRange().getMin(),

							ddlRelType.getSecondRange().getMax() > this.horizon ? 

									this.horizon : 

									ddlRelType.getSecondRange().getMax()

						}

					});

		}

		else if (ddlRelType.getText().equalsIgnoreCase("ends-during")) {

			problem.addTemporalConstraint(RelationType.ENDS_DURING, reference, target, 

					new long[][] {

						new long[] {

							ddlRelType.getFirstRange().getMin(),

							ddlRelType.getFirstRange().getMax() > this.horizon ? 

									this.horizon :

									ddlRelType.getFirstRange().getMax()

						},

						new long[] {

								ddlRelType.getSecondRange().getMin(),

								ddlRelType.getSecondRange().getMax() > this.horizon ? 

										this.horizon : 

										ddlRelType.getSecondRange().getMax()

							}

					});

		}

		else {

		}

	}

	/**

	 * 

	 * @param pdb

	 */

	private void addParameterDomains(PlanDataBase pdb) {

		// add parameter domains 

		for (String name : this.ddl_domain.getParameterTypes().keySet()) {

			// get parameter declaration

			DDLParameterType pDomType = this.ddl_domain.getParameterTypes().get(name);

			// check type

			switch (pDomType.getDomainType()) 

			{

				// numeric parameter

				case NUMERIC : {

					// get numeric domain

					DDLNumericParameterType numeric = (DDLNumericParameterType) pDomType;

					// create domain parameter

					NumericParameterDomain dom  = pdb.createParameterDomain(name, ParameterDomainType.NUMERIC_DOMAIN_PARAMETER_TYPE);

					// set bounds

					dom.setLowerBound(numeric.getLowerBound());

					dom.setUpperBound(numeric.getUpperBound());

				}

				break;

				// enumeration parameter

				case ENUMERATION : {

					// get enumeration domain

					DDLEnumerationParameterType enumeration = (DDLEnumerationParameterType) pDomType;

					// create domain parameter

					EnumerationParameterDomain dom = pdb.createParameterDomain(name, ParameterDomainType.ENUMERATION_DOMAIN_PARAMETER_TYPE);

					// set values

					dom.setValues(enumeration.getEnums().toArray(new String[enumeration.getEnums().size()]));

				}

				break;

			}

		}

	}

	/**

	 * 

	 * @param pdb

	 */

	private void addComponents(PlanDataBase pdb) 

	{

		// get domain components

		for (DDLComponent ddlComponent : this.ddl_domain.getComponents().values()) 

		{

			// get component type

			DDLComponentType ctype = this.ddl_domain.getComponentTypes().get(ddlComponent.getComponentType());

			// check component type

			if (ctype instanceof DDLSingletonStateVariableComponentType) 

			{

				// add state variable

				this.addStateVariable(pdb, ddlComponent);

			}

			else if (ctype instanceof DDLRenewableResourceComponentType)

			{

				// add discrete resource

				this.addDiscreteResource(pdb, ddlComponent);

			}

			else if (ctype instanceof DDLConsumableResourceComponentType)

			{

				// add reservoir resource

				this.addReservoirResource(pdb, ddlComponent);

			}

			else {

				// unknown 

						+ "- Parsed component " + ddlComponent.getName() + " (" + ddlComponent.getType() + ")\n"

						+ "- " + ctype + "\n");

			}

		}

	}

	/**

	 * 

	 * @param pdb

	 * @throws SynchronizationCycleException

	 */

	private void addSynchronizationRules(PlanDataBase pdb) 

			throws SynchronizationCycleException 

	{

		try 

		{

			// add synchronization on components

			for (DDLTimelineSynchronization ddlComponentSynch : this.ddl_domain.getTimelineSynchronizations()) 

			{

				// get reference component

				DomainComponent comp = pdb.getComponentByName(ddlComponentSynch.getComponent());

				// check component's synchronizations

				for (DDLSynchronization ddlSynch : ddlComponentSynch.getSynchronizations()) 

				{

					// get synchronization's reference

					DDLComponentDecision ddlReference = ddlSynch.getReference();

					// check type

					switch (ddlReference.getDecisionType()) 

					{

						// singleton decision

						case SINGLETON : {

							// create synchronization 

							this.doCreateSynchronizationFromSingletonDecision(ddlSynch, comp, pdb);

						}

						break;

						// ground decision

						case GROUND : {

							// create synchronization

							this.doCreateSynchronizationFromGroundDecision(ddlSynch, comp, pdb);

						}

						break;

						// reservoir resource usage

						case CONSUMABLE_RESOURCE_REQUIREMENT : {

							// create synchronization

							this.doCreateSynchronizationFromConsumableResourceValue(ddlSynch, (ReservoirResource) comp, pdb);

						}

						break;

						// discrete resource usage

							 // create synchronization

							this.doCreateSynchronizationFromRenewableResourceValue(ddlSynch, (DiscreteResource) comp, pdb);

						}

						default : {

						}

					}

				}

			}

		}

		catch (DomainComponentNotFoundException ex) {

		}

	}

	/**

	 * 

	 * @param ddlSynch

	 * @param comp

	 * @param pdb

	 * @throws DomainComponentNotFoundException

	 * @throws SynchronizationCycleException

	 */

			throws DomainComponentNotFoundException, SynchronizationCycleException

	{

		// setup auxiliary data structures

		Map<String, TokenVariable> label2variable = new HashMap<>();

		Map<String, TokenVariable> decId2variable = new HashMap<>();

		// get reference decision

		DDLRenewableResourceComponentDecision ddlDec = (DDLRenewableResourceComponentDecision) ddlSynch.getReference();

		// get trigger value

		RequirementResourceValue valTrigger = comp.getRequirementValue();

		// create synchronization

		SynchronizationRule rule = pdb.createSynchronizationRule(valTrigger, new String[] {ddlDec.getRequirementName()}); 

		// add entry to parameter label index

		for (String label : rule.getTriggerer().getParameterLabels()) {

			label2variable.put(label, rule.getTriggerer());

		}

		// check target values

		for (DDLInstantiatedComponentDecision ddlTarget : ddlSynch.getTargets().values()) 

		{

			// get target component

			DomainComponent targetComponent = pdb.getComponentByName(ddlTarget.getComponent());

			// check target component type

			switch (targetComponent.getType())

			{

				// state variable component

				case SV_EXTERNAL : 

				case SV_FUNCTIONAL : 

				case SV_PRIMITIVE : 

				{

					// check target decision

					DDLComponentDecision ddlTargetDecision = ddlTarget.getComponentDecision();

					// check decision type

					switch (ddlTargetDecision.getDecisionType())

					{

						// decision with parameters

						case SINGLETON :

						{

							// cast decision

							DDLSingletonStateVariableComponentDecision ddlSingletonTarget = (DDLSingletonStateVariableComponentDecision) ddlTargetDecision;

							// get target value

							ComponentValue targetValue = targetComponent.getValueByName(ddlSingletonTarget.getName());

							// add token variable

							TokenVariable target = rule.addTokenVariable(targetValue, 

									ddlSingletonTarget.getParameterNames().toArray(new String[ddlSingletonTarget.getParameterNames().size()]));

							// check solving knowledge

							if (!ddlTarget.getParameters().isEmpty()) {

								// check mandatory expansion

								if (ddlTarget.getParameters().contains("!")) {

									// set knowledge

									target.setMandatoryExpansion();

								}

								// check mandatory unification

								if (ddlTarget.getParameters().contains("?")) {

									target.setMandatoryUnification();

								}

							}

							// add entry to index

							for (String label : target.getParameterLabels()) {

								// add entry

								label2variable.put(label, target);

							}

							// get synchronization decision's ID

							String id = ddlTarget.getId();

							// check if target id already exists 

							if (decId2variable.containsKey(id)) {

							}

							// add entry 

							decId2variable.put(id, target);

						}

						break;

						// ground decision

						case GROUND : 

						{

							// cast decision

							DDLSimpleGroundStateVariableComponentDecision ddlGroundTarget = (DDLSimpleGroundStateVariableComponentDecision) ddlTargetDecision;

							// get target value

							ComponentValue targetValue = targetComponent.getValueByName(ddlGroundTarget.getName());

							// add token variable with no parameter labels

							TokenVariable target = rule.addTokenVariable(targetValue, new String[] {}); 

							// check solving knowledge

							if (!ddlTarget.getParameters().isEmpty()) {

								// check mandatory expansion

								if (ddlTarget.getParameters().contains("!")) {

									// set knowledge

									target.setMandatoryExpansion();

								}

								// check mandatory unification

								if (ddlTarget.getParameters().contains("?")) {

									target.setMandatoryUnification();

								}

							}

							// get synchronization decision's ID

							String id = ddlTarget.getId();

							// check if target id already exists 

							if (decId2variable.containsKey(id)) {

							}

							// add entry 

							decId2variable.put(id, target);

						}

						break;

						default : {

						}

					}

				}

				break;

				// discrete resource component

				case RESOURCE_DISCRETE : 

				{

					// check target decision

					DDLComponentDecision ddlTargetDecision = ddlTarget.getComponentDecision();

					// cast decision

					DDLRenewableResourceComponentDecision ddlRequirementTarget = (DDLRenewableResourceComponentDecision) ddlTargetDecision;

					// get target component

					DiscreteResource resource = (DiscreteResource) targetComponent;

					// get target value 

					ComponentValue targetValue = resource.getRequirementValue();

					// add token variable

					TokenVariable target = rule.addTokenVariable(targetValue,

							new String[] {ddlRequirementTarget.getRequirementName()});

					// add entry to index

					for (String label : target.getParameterLabels()) {

						// add entry

						label2variable.put(label, target);

					}

					// get synchronization decision's ID

					String id = ddlTarget.getId();

					// check if target id already exists 

					if (decId2variable.containsKey(id)) {

					}

					// add entry 

					decId2variable.put(id, target);

				}

				break;

				// reservoir resource component

				case RESOURCE_RESERVOIR : 

				{

					// get target component

					ReservoirResource resource = (ReservoirResource) targetComponent;

					// check target decision

					DDLComponentDecision ddlTargetDecision = ddlTarget.getComponentDecision();

					// cast decision

					DDLConsumableResourceComponentDecision ddlConsumableTarget = (DDLConsumableResourceComponentDecision) ddlTargetDecision;

					// check decision type

					switch (ddlConsumableTarget.getComponentDecisionType())

					{

						// resource consumption

						case Consumption : 

						{

							// get target value 

							ComponentValue consumption = resource.getConsumptionValue();

							// add token variable

							TokenVariable target = rule.addTokenVariable(consumption,

									new String[] {ddlConsumableTarget.getParameterName()});

							// add entry to index

							for (String label : target.getParameterLabels()) {

								// add entry

								label2variable.put(label, target);

							}

							// get synchronization decision's ID

							String id = ddlTarget.getId();

							// check if target id already exists 

							if (decId2variable.containsKey(id)) {

							}

							// add entry 

							decId2variable.put(id, target);

						}

						break;

						// resource production 

						case Production : 

						{

							// get target value 

							ComponentValue production = resource.getProductionValue();

							// add token variable

							TokenVariable target = rule.addTokenVariable(production,

									new String[] {ddlConsumableTarget.getParameterName()});

							// add entry to index

							for (String label : target.getParameterLabels()) {

								// add entry

								label2variable.put(label, target);

							}

							// get synchronization decision's ID

							String id = ddlTarget.getId();

							// check if target id already exists 

							if (decId2variable.containsKey(id)) {