// here, we also identify what parameters should be foldered
  private Pair<String, Object> processDependentParameter(
      ComputeParameter par,
      Hashtable<String, Object> line,
      Hashtable<String, String> simpleValues) {
    Pair<String, Object> pair = new Pair<String, Object>();
    pair.setA(par.getName());

    int lineFolderedSize = foldingParser.getFolderedLineSize(line);
    String parTemplate = par.getDefaultValue();

    foldingParser.setNotList();
    foldingParser.checkIsList(parTemplate);
    boolean isList = foldingParser.getIsList();

    if (lineFolderedSize > 1 && isList) {
      List<String> values = new ArrayList<String>();
      for (int i = 0; i < lineFolderedSize; i++) {
        String value = foldingParser.parseTemplateLineByHand(parTemplate, line, i, simpleValues);
        values.add(value);
      }
      pair.setB(values);
    } else {
      String value = foldingParser.parseTemplateLineByHand(parTemplate, line, 0, simpleValues);
      pair.setB(value);
    }
    return pair;
  }
 private boolean isTarget(String ekey, List<ComputeParameter> targets) {
   for (ComputeParameter par : targets) {
     String name = par.getName();
     if (name.equalsIgnoreCase(ekey)) return true;
   }
   return false;
 }
  private GridTransferContainer fillContainer(
      ComputeProtocol protocol, Hashtable<String, Object> values) {
    GridTransferContainer container = new GridTransferContainer();

    List<ComputeParameter> inputs = protocol.getInputs();
    for (ComputeParameter input : inputs) {
      String name = input.getName();
      String value = (String) values.get(name);
      container.addInput(name, value);
    }

    List<ComputeParameter> outputs = protocol.getOutputs();
    for (ComputeParameter output : outputs) {
      String name = output.getName();
      String value = (String) values.get(name);
      container.addOutput(name, value);
    }

    List<ComputeParameter> exes = protocol.getExes();
    for (ComputeParameter exe : exes) {
      String name = exe.getName();
      String value = (String) values.get(name);
      container.addExe(name, value);
    }

    List<ComputeParameter> logs = protocol.getLogs();
    for (ComputeParameter log : logs) {
      String name = log.getName();
      String value = (String) values.get(name);
      container.addLog(name, value);
    }

    return container;
  }
  public Vector<ComputeJob> generateComputeJobsFoldedWorksheet(
      Workflow workflow, List<Tuple> f, String backend) {
    // create the table with targets, which is equal to worksheet if there are no targets
    List<Hashtable> table = null;

    // check if workflow elements have dependencies
    workflowHasDependencies = hasDependencies(workflow);

    // remove unused parameters from the worksheet
    List<Hashtable> worksheet = foldingMaker.transformToTable(f);
    foldingMaker.setWorkflow(workflow);
    worksheet =
        foldingMaker.removeUnused(
            worksheet, (List<ComputeParameter>) workflow.getWorkflowComputeParameterCollection());

    // result jobs
    Vector<ComputeJob> computeJobs = new Vector<ComputeJob>();

    // if (backend.equalsIgnoreCase(JobGenerator.GRID))
    pairJobTransfers = new Hashtable<String, GridTransferContainer>();

    pairWEtoCJ = new Hashtable<WorkflowElement, ComputeJob>();
    pairCJtoWE = new Hashtable<ComputeJob, WorkflowElement>();

    if (backend.equalsIgnoreCase(JobGenerator.CLUSTER)) {
      submitScript = "";
    } else if (backend.equalsIgnoreCase(JobGenerator.GRID) && workflowHasDependencies) {
      dagScript = "Type=\"dag\";\n\n";
      dagDependencies = "";
    }

    Collection<ComputeParameter> parameters = workflow.getWorkflowComputeParameterCollection();
    Collection<WorkflowElement> workflowElements = workflow.getWorkflowWorkflowElementCollection();
    for (WorkflowElement el : workflowElements) {

      ComputeProtocol protocol = (ComputeProtocol) el.getProtocol();
      String template = protocol.getScriptTemplate();

      // chack if we have any targets
      List<ComputeParameter> targets = foldingMaker.findTargets(protocol.getScriptTemplate());
      if (targets != null) {
        table = foldingMaker.fold(targets, worksheet);
      } else table = worksheet;

      // here, we prapare some information about folded table
      // in particular, we find what parameters are Martijn's folded constants
      foldingParser.evaluateTable(table);

      // we set all parameters to foldered parser, which are used for reducing foldered constants
      // this comment does give any clue to what is going on :)
      foldingParser.setParametersList(parameters);

      // now we start to use foldered worksheet
      // all our parameters, that depend on foldered worksheet, will become lists as well, that
      // upset me a lot :(
      for (int i = 0; i < table.size(); i++) {
        // because Hashtable does not allow null keys or values used for weaving
        Hashtable<String, Object> values = new Hashtable<String, Object>();

        // parameters which are templates and do directly depend on worksheet values
        Vector<ComputeParameter> complexParameters = new Vector<ComputeParameter>();

        // hashtable with simple values, we need it for initial weaving
        Hashtable<String, String> simpleValues = new Hashtable<String, String>();

        // job naming
        String id = "id";
        Hashtable<String, Object> line = table.get(i);

        if (targets != null) {
          // use targets to create name
          Enumeration ekeys = line.keys();
          while (ekeys.hasMoreElements()) {
            String ekey = (String) ekeys.nextElement();
            if (isTarget(ekey, targets)) {
              Object eValues = line.get(ekey);
              values.put(ekey, eValues);
              String vvv = eValues.toString();
              vvv = vvv.replaceAll(" ", "_");
              id += "_" + vvv;
            }
          }

        } else {
          // use the whole line to create name
          Enumeration ekeys = line.keys();
          while (ekeys.hasMoreElements()) {
            String ekey = (String) ekeys.nextElement();
            Object eValues = line.get(ekey);
            values.put(ekey, eValues);
            String vvv = eValues.toString();
            vvv = vvv.replaceAll(" ", "_");
            id += "_" + vvv;
          }
        }

        for (ComputeParameter parameter : parameters) {
          if (parameter.getDefaultValue() != null) {
            if (parameter.getDefaultValue().contains("${")) {
              complexParameters.addElement(parameter);
            } else {
              values.put(parameter.getName(), parameter.getDefaultValue());
              simpleValues.put(parameter.getName(), parameter.getDefaultValue());
            }
          }
        }
        logger.log(Level.DEBUG, "simple parameters before: " + values.size());

        // we transform complex parameters to unweaved values, because unweaved value can folded
        Hashtable<String, Object> unweavedValues = new Hashtable<String, Object>();

        for (ComputeParameter par : complexParameters) {
          Pair<String, Object> value = processDependentParameter(par, line, simpleValues);
          if (foldingParser.isValueSimple(value)) {
            values.put(par.getName(), value.getB());
          } else {
            unweavedValues.put(par.getName(), value.getB());
          }
        }

        logger.log(
            Level.DEBUG,
            "simple parameters after "
                + values.size()
                + "  parameters to weave: "
                + complexParameters.size());

        Vector<String> vecToRemove = new Vector<String>();

        int weavingCount = 0;
        logger.log(Level.DEBUG, "loop " + weavingCount + " -> " + unweavedValues.size());
        // in a loop weave complex parameters with values
        while (unweavedValues.size() > 0 && weavingCount < 100) {
          Enumeration unkeys = unweavedValues.keys();
          while (unkeys.hasMoreElements()) {
            String unkey = (String) unkeys.nextElement();
            Object eValue = unweavedValues.get(unkey);

            Pair<String, Object> value = null;

            if (eValue instanceof Collection<?>) {
              List<String> unweavedLines = (List<String>) eValue;
              value = processUnweavedCollection(unkey, unweavedLines, values);
            } else {
              String unweavedLine = (String) eValue;
              value = processUnweavedLine(unkey, unweavedLine, values, 0);
            }

            if (foldingParser.isValueSimple(value)) {
              values.put(value.getA(), value.getB());
              vecToRemove.add(unkey);
            } else unweavedValues.put(value.getA(), value.getB());
          }

          for (String str : vecToRemove) unweavedValues.remove(str);
          weavingCount++;

          logger.log(
              Level.DEBUG,
              "loop/parameters to weave " + weavingCount + " -> " + unweavedValues.size());
        }

        String jobListing = foldingMaker.weaveFreemarker(template, values);

        ComputeJob job = new ComputeJob();

        String jobName =
            config.get(JobGenerator.GENERATION_ID)
                + "_"
                + workflow.getName()
                + "_"
                + el.getName()
                + "_"
                + id;

        job.setName(jobName);
        job.setProtocol(protocol);
        job.setComputeScript(jobListing);
        computeJobs.add(job);

        // fill containers for grid jobs to ensure correct data transfer
        // and for cluster to generate submit script
        // if (backend.equalsIgnoreCase(JobGenerator.GRID))
        {
          GridTransferContainer container = fillContainer(protocol, values);
          pairJobTransfers.put(job.getName(), container);
        }
        // else if (backend.equalsIgnoreCase(JobGenerator.CLUSTER))
        {
          pairWEtoCJ.put(el, job);
          pairCJtoWE.put(job, el);
        }
        logger.log(
            Level.DEBUG, "----------------------------------------------------------------------");
        logger.log(Level.DEBUG, el.getName());
        logger.log(Level.DEBUG, jobListing);
        logger.log(
            Level.DEBUG, "----------------------------------------------------------------------");
      }
    }
    return computeJobs;
  }