taskmanagerimpl.java

It is all about project scheduling. GanttProject is a tool for creating a project schedule by means

/*
 * Created on 05.07.2003
 *
 */
package net.sourceforge.ganttproject.task;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

import net.sourceforge.ganttproject.GanttCalendar;
import net.sourceforge.ganttproject.GanttTask;
import net.sourceforge.ganttproject.GanttTaskRelationship;
import net.sourceforge.ganttproject.Mediator;
import net.sourceforge.ganttproject.calendar.AlwaysWorkingTimeCalendarImpl;
import net.sourceforge.ganttproject.calendar.GPCalendar;
import net.sourceforge.ganttproject.calendar.GPCalendarActivity;
import net.sourceforge.ganttproject.resource.HumanResource;
import net.sourceforge.ganttproject.resource.ResourceManager;
import net.sourceforge.ganttproject.task.algorithm.AdjustTaskBoundsAlgorithm;
import net.sourceforge.ganttproject.task.algorithm.AlgorithmCollection;
import net.sourceforge.ganttproject.task.algorithm.CriticalPathAlgorithm;
import net.sourceforge.ganttproject.task.algorithm.CriticalPathAlgorithmImpl;
import net.sourceforge.ganttproject.task.algorithm.FindPossibleDependeesAlgorithm;
import net.sourceforge.ganttproject.task.algorithm.FindPossibleDependeesAlgorithmImpl;
import net.sourceforge.ganttproject.task.algorithm.ProjectBoundsAlgorithm;
import net.sourceforge.ganttproject.task.algorithm.RecalculateTaskCompletionPercentageAlgorithm;
import net.sourceforge.ganttproject.task.algorithm.RecalculateTaskScheduleAlgorithm;
import net.sourceforge.ganttproject.task.algorithm.ProjectBoundsAlgorithm.Result;
import net.sourceforge.ganttproject.task.dependency.EventDispatcher;
import net.sourceforge.ganttproject.task.dependency.TaskDependency;
import net.sourceforge.ganttproject.task.dependency.TaskDependencyCollection;
import net.sourceforge.ganttproject.task.dependency.TaskDependencyCollectionImpl;
import net.sourceforge.ganttproject.task.dependency.TaskDependencyConstraint;
import net.sourceforge.ganttproject.task.dependency.TaskDependencyException;
import net.sourceforge.ganttproject.task.dependency.constraint.FinishFinishConstraintImpl;
import net.sourceforge.ganttproject.task.dependency.constraint.FinishStartConstraintImpl;
import net.sourceforge.ganttproject.task.dependency.constraint.StartFinishConstraintImpl;
import net.sourceforge.ganttproject.task.dependency.constraint.StartStartConstraintImpl;
import net.sourceforge.ganttproject.task.event.TaskDependencyEvent;
import net.sourceforge.ganttproject.task.event.TaskHierarchyEvent;
import net.sourceforge.ganttproject.task.event.TaskListener;
import net.sourceforge.ganttproject.task.event.TaskPropertyEvent;
import net.sourceforge.ganttproject.task.event.TaskScheduleEvent;
import net.sourceforge.ganttproject.task.hierarchy.TaskHierarchyManagerImpl;
import net.sourceforge.ganttproject.time.DateFrameable;
import net.sourceforge.ganttproject.time.TimeUnit;
import net.sourceforge.ganttproject.time.gregorian.GregorianCalendar;

/**
 * @author bard
 */
public class TaskManagerImpl implements TaskManager {
    private static final GPCalendar RESTLESS_CALENDAR = new AlwaysWorkingTimeCalendarImpl();
    private final TaskHierarchyManagerImpl myHierarchyManager;

    private final TaskDependencyCollectionImpl myDependencyCollection;

    private final AlgorithmCollection myAlgorithmCollection;

    private final List myListeners = new ArrayList();

    private int myMaxID = -1;


    private Task myRoot;

    private final TaskManagerConfig myConfig;

    private final TaskContainmentHierarchyFacade.Factory myFacadeFactory;

    private TaskContainmentHierarchyFacade myTaskContainment;

    private static class TaskMap {
        private final Map myId2task = new HashMap();
		private TaskDocumentOrderComparator myComparator;
		private boolean isModified = true;
		private Task[] myArray;
        private final TaskManagerImpl myManager;
    	TaskMap(TaskManagerImpl taskManager) {
    		myComparator = new TaskDocumentOrderComparator(taskManager);
            myManager = taskManager;
    	}
    	void addTask(Task task) {
    		myId2task.put(new Integer(task.getTaskID()), task);
    		isModified = true;
    	}
    	Task getTask(int id) {
    		return (Task) myId2task.get(new Integer(id));
    	}
		public Task[] getTasks() {
			if (isModified) {
				myArray = (Task[]) myId2task.values().toArray(new Task[myId2task.size()]);
				Arrays.sort(myArray, myComparator);
				isModified = false;
			}
			return myArray;
		}
		public void clear() {
			myId2task.clear();
			isModified = true;
		}
		public void removeTask(Task task) {
			myId2task.remove(new Integer(task.getTaskID()));
            Task[] nestedTasks = myManager.getTaskHierarchy().getNestedTasks(task);
            for (int i=0; i<nestedTasks.length; i++) {
                removeTask(nestedTasks[i]);
            }
			isModified = true;
		}
		public int size() {
			return myId2task.size();
		}
		public boolean isEmpty() {
			return myId2task.isEmpty();
		}
		void setDirty() {
			isModified = true;
		}
    }
    private final TaskMap myTaskMap = new TaskMap(this);
    
    TaskManagerImpl(
            TaskContainmentHierarchyFacade.Factory containmentFacadeFactory,
            TaskManagerConfig config) {
        myConfig = config;
        CustomColumnsStorage customColumnsStorage = new CustomColumnsStorage();
        Mediator.registerCustomColumnsStorage(customColumnsStorage);
        myHierarchyManager = new TaskHierarchyManagerImpl();
        EventDispatcher dispatcher = new EventDispatcher() {
            public void fireDependencyAdded(TaskDependency dep) {
                TaskManagerImpl.this.fireDependencyAdded(dep);
            }

            public void fireDependencyRemoved(TaskDependency dep) {
                TaskManagerImpl.this.fireDependencyRemoved(dep);
            }
        };
        myDependencyCollection = new TaskDependencyCollectionImpl(containmentFacadeFactory, dispatcher) {
            private TaskContainmentHierarchyFacade myTaskHierarchy;

            protected TaskContainmentHierarchyFacade getTaskHierarchy() {
                if (myTaskHierarchy == null) {
                    myTaskHierarchy = TaskManagerImpl.this.getTaskHierarchy();
                }
                return myTaskHierarchy;
            }
        };
        myFacadeFactory = containmentFacadeFactory == null ? new FacadeFactoryImpl()
                : containmentFacadeFactory;
        // clear();
        {
            Date today = GregorianCalendar.getInstance().getTime();
            myRoot = new GanttTask(null, new GanttCalendar(today), 1, this, -1);
            myRoot.setStart(new GanttCalendar(GregorianCalendar.getInstance()
                    .getTime()));
            myRoot.setDuration(createLength(getConfig().getTimeUnitStack()
                    .getDefaultTimeUnit(), 1));
            myRoot.setExpand(true);

        }

        FindPossibleDependeesAlgorithm alg1 = new FindPossibleDependeesAlgorithmImpl() {
            protected TaskContainmentHierarchyFacade createContainmentFacade() {
                return TaskManagerImpl.this.getTaskHierarchy();
            }

        };
        AdjustTaskBoundsAlgorithm alg3 = new AdjustTaskBoundsAlgorithm() {
            protected TaskContainmentHierarchyFacade createContainmentFacade() {
                return TaskManagerImpl.this.getTaskHierarchy();
            }
        };
        RecalculateTaskScheduleAlgorithm alg2 = new RecalculateTaskScheduleAlgorithm(
                alg3) {
            protected TaskContainmentHierarchyFacade createContainmentFacade() {
                return TaskManagerImpl.this.getTaskHierarchy();
            }
        };
        RecalculateTaskCompletionPercentageAlgorithm alg4 = new RecalculateTaskCompletionPercentageAlgorithm() {
            protected TaskContainmentHierarchyFacade createContainmentFacade() {
                return TaskManagerImpl.this.getTaskHierarchy();
            }
        };
        ProjectBoundsAlgorithm alg5 = new ProjectBoundsAlgorithm();
        myAlgorithmCollection = new AlgorithmCollection(alg1, alg2, alg3, alg4,
                alg5);
    }

    /*
     * (non-Javadoc)
     * 
     * @see net.sourceforge.ganttproject.task.TaskManager#getTask(int)
     */
    public GanttTask getTask(int taskId) {
        return (GanttTask) myTaskMap.getTask(taskId);
    }

    public Task getRootTask() {
        if (myRoot == null) {
        }
        return myRoot;
    }

    public Task[] getTasks() {
    	return myTaskMap.getTasks();
        //return (Task[]) myId2task.values().toArray(new Task[myId2task.size()]);
    }

    /*
     * (non-Javadoc)
     * 
     * @see net.sourceforge.ganttproject.task.TaskManager#clear()
     */
    public void clear() {
        myTaskMap.clear();
        setMaxID(-1);
        myDependencyCollection.clear();
        {
            Date today = GregorianCalendar.getInstance().getTime();
            myRoot = new GanttTask(null, new GanttCalendar(today), 1, this, -1);
            myRoot.setStart(new GanttCalendar(GregorianCalendar.getInstance()
                    .getTime()));
            myRoot.setDuration(createLength(getConfig().getTimeUnitStack()
                    .getDefaultTimeUnit(), 1));
            myRoot.setExpand(true);

        }
    }

    public void deleteTask(Task tasktoRemove) {
        myTaskMap.removeTask(tasktoRemove);
        // TaskDependency[] dep =
        // myDependencyCollection.getDependencies(tasktoRemove);
        // for(int i=0;i<dep.length; i++){
        // dep[i].delete();
        // }
        // todo REMOVE TASK FROM TASKHIERARCHY
        // fireTaskRemoved(tasktoRemove,myTaskContainment.getContainer(tasktoRemove));
        
    }

    public GanttTask createTask() {
        GanttTask result = createTask(-1);
        return result;
    }

    /*
     * (non-Javadoc)
     * 
     * @see net.sourceforge.ganttproject.task.TaskManager#createTask(int)
     */
    public GanttTask createTask(int taskID) {
        GanttTask result = new GanttTask("", new GanttCalendar(), 1, this,
                taskID);
        if (result.getTaskID() >= getMaxID()) {
            setMaxID(result.getTaskID() + 1);
        }
        // result.setTaskID(taskID);
        // getTaskHierarchy().move(result, getRootTask());
        // result.move(getRootTask());
        fireTaskAdded(result);
        return result;
    }

    /*
     * (non-Javadoc)
     * 
     * @see net.sourceforge.ganttproject.task.TaskManager#registerTask(net.sourceforge.ganttproject.GanttTask)
     */
    public void registerTask(Task task) {
        int taskID = task.getTaskID();
        if (myTaskMap.getTask(taskID) == null) { // if the taskID is
            // not in the map
            myTaskMap.addTask(task);
            if (getMaxID() < taskID) {
                setMaxID(taskID + 1);
            }
        } else { // taskID has been in the map. the newTask will not be added
            throw new RuntimeException(
                    "There is a task that already has the ID " + taskID);
        }
    }

	boolean isRegistered(TaskImpl task) {
		return myTaskMap.getTask(task.getTaskID())!=null;
	}