Exemple #1
0
 public void addResource(Resource r) {
   this.requiredResources.put(r.getResourceID(), r);
 }
Exemple #2
0
  /**
   * Calculate the starTime and endTime for the collection of tasks. Takes into account resources
   * and does not allow two tasks with shared resources run at the same time. It's not very "smart",
   * though, and won't optimize the order of the tasks at all.
   *
   * @param children tasks
   * @param startTime start time for this collection of tasks to start at
   */
  public void startTimeChild(HashMap<String, Task> children, int startTime) {
    Queue<Task> queue = new LinkedList<Task>();

    // make a resource list for each resource
    HashMap<String, List<Task>> resourceLists = new HashMap<String, List<Task>>();

    // loop through children
    for (Task child : children.values()) {
      System.out.println("pre-processing: " + child);

      // add children to the resource list
      for (Resource resource : child.getRequiredResources().values()) {
        // check if the resource exists in our Resource List
        if (!resourceLists.containsKey(resource.getResourceID())) {
          // if not, add it
          resourceLists.put(resource.getResourceID(), new LinkedList<Task>());
        }
      }

      // if it's a starting Task, add it to the queue
      if (child.getPredecessors().isEmpty()) {
        // put into queue
        queue.add(child);

        // set start and end times to -1
        child.setStartTime(-1);
        child.setEndTime(-1);
      }
    }

    // Loop through queue, as we go we'll
    // 0. calculate the startTime of the task
    // 1. add it to the resource list(s) / deal with resources
    //   1a. assign start time of task
    // 2. deal with any children
    // 3. calculate duration and endTime
    // 4. put any successors on the queue

    System.out.println("starting queue:");

    while (!queue.isEmpty()) {
      System.out.println("pop");
      Task child = queue.remove();

      System.out.println(child);

      int idealStartTime = -1; // the startTime that would be ideal, if resources weren't an issue
      // 0. calculate the startTime of the task
      System.out.println(" 0");
      if (child.getPredecessors().isEmpty()) {
        idealStartTime = startTime;
      } else {
        idealStartTime = maxEndTime(child.getPredecessors().values());
      }

      int realisticStartTime =
          idealStartTime; // the startTime that must be done, because of resource conflicts

      // 1. add to resource list(s) / deal with resources
      System.out.println(" 1");
      for (Resource resource : child.getRequiredResources().values()) {
        // check to see if there's a task using this resource. if so, our startTime must be after
        // their endTime
        for (Task task : resourceLists.get(resource.getResourceID())) {
          realisticStartTime =
              (task.getEndTime() < realisticStartTime) ? realisticStartTime : task.getEndTime();
        }

        // add this child to that list
        if (!resourceLists.get(resource.getResourceID()).contains(resource)) {
          resourceLists.get(resource.getResourceID()).add(child);
        }

        // see what else is on there..
        System.out.println(
            " " + resource.getname() + ": " + resourceLists.get(resource.getResourceID()));
      }

      // 1b. Assign the startTime of a task
      System.out.println("  1b");
      child.setStartTime(realisticStartTime);
      System.out.println(" startTime: " + realisticStartTime);

      // 2. deal with any children
      System.out.println(" 2");
      if (!child.getChildren().isEmpty()) {
        startTimeChild(child.getChildren(), child.getStartTime());
      }

      // 3. set this child's duration & endTime
      System.out.println(" 3");
      child.setDuration(
          Math.max(
              child.getDuration(),
              maxEndTime(child.getChildren().values()) - child.getStartTime()));
      child.setEndTime(child.getStartTime() + child.getDuration());

      // 4. put their successors in the queue
      System.out.println(" 4");
      for (Task successor : child.getSuccessors().values()) {
        queue.add(successor);
      }
    }

    System.out.println("--->ending");
  }