From 2cbdacf33bf6ccd973ffb8884a6c038b025beaf3 Mon Sep 17 00:00:00 2001 From: spingel Date: Tue, 15 Apr 2008 02:27:20 +0000 Subject: NEW - bug 225485: [api] move TasksUiPlugin to internal package https://bugs.eclipse.org/bugs/show_bug.cgi?id=225485 --- .../internal/tasks/core/TaskActivityManager.java | 1 - .../mylyn/internal/tasks/core/TaskArchive.java | 1 - .../mylyn/internal/tasks/core/TaskList.java | 1397 ++++++++++++++++++++ .../internal/tasks/core/TaskRepositoryManager.java | 1 - .../sync/RepositorySynchronizationManager.java | 6 +- .../tasks/core/sync/SynchronizeAllTasksJob.java | 6 +- .../tasks/core/sync/SynchronizeQueriesJob.java | 2 +- .../core/sync/SynchronizeRepositoriesJob.java | 2 +- .../tasks/core/sync/SynchronizeTasksJob.java | 6 +- 9 files changed, 1408 insertions(+), 14 deletions(-) create mode 100644 org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskList.java (limited to 'org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks') diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java index b34864cc1..8508c3f39 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java @@ -28,7 +28,6 @@ import org.eclipse.mylyn.monitor.core.InteractionEvent; import org.eclipse.mylyn.monitor.core.StatusHandler; import org.eclipse.mylyn.tasks.core.AbstractTask; import org.eclipse.mylyn.tasks.core.ITaskTimingListener; -import org.eclipse.mylyn.tasks.core.TaskList; /** * Manager for Task timing, scheduling, due dates, and activation history diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskArchive.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskArchive.java index 33a345f75..26b03891e 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskArchive.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskArchive.java @@ -13,7 +13,6 @@ import java.util.Set; import org.eclipse.mylyn.tasks.core.AbstractTask; import org.eclipse.mylyn.tasks.core.AbstractTaskCategory; -import org.eclipse.mylyn.tasks.core.TaskList; import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel; /** diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskList.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskList.java new file mode 100644 index 000000000..970ee762a --- /dev/null +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskList.java @@ -0,0 +1,1397 @@ +/******************************************************************************* + * Copyright (c) 2004, 2007 Mylyn project committers and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + *******************************************************************************/ + +package org.eclipse.mylyn.internal.tasks.core; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.CopyOnWriteArraySet; + +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.jobs.ILock; +import org.eclipse.core.runtime.jobs.ISchedulingRule; +import org.eclipse.core.runtime.jobs.Job; +import org.eclipse.mylyn.monitor.core.StatusHandler; +import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery; +import org.eclipse.mylyn.tasks.core.AbstractTask; +import org.eclipse.mylyn.tasks.core.AbstractTaskCategory; +import org.eclipse.mylyn.tasks.core.AbstractTaskContainer; +import org.eclipse.mylyn.tasks.core.ITaskList; +import org.eclipse.mylyn.tasks.core.ITaskListChangeListener; +import org.eclipse.mylyn.tasks.core.TaskContainerDelta; + +/** + * Stores and manages task list elements and their containment hierarchy. + * + * @author Mik Kersten + * @author Rob Elves + * @since 2.0 + */ +public class TaskList implements ISchedulingRule, ITaskList { + + private int lastLocalTaskId = 0; + + private final Set changeListeners = new CopyOnWriteArraySet(); + + private Map repositoryOrphansMap; + + private Map tasks; + + private Map categories; + + private Map queries; + + private List activeTasks; + + private UncategorizedTaskContainer defaultCategory; + + private static ILock lock = Job.getJobManager().newLock(); + + public TaskList() { + reset(); + } + + /** + * precondition: task must not be null and must exist in the task list + * + * @since 2.2 + */ + private void addOrphan(AbstractTask task, Set delta) { + + if (!task.getParentContainers().isEmpty()) { + // Current policy is not to archive/orphan if the task exists in some other container + return; + } + + if (task instanceof LocalTask) { + try { + lock.acquire(); + defaultCategory.internalAddChild(task); + } finally { + lock.release(); + } + task.addParentContainer(defaultCategory); + return; + } + + UnmatchedTaskContainer orphans; + + try { + lock.acquire(); + orphans = repositoryOrphansMap.get(task.getRepositoryUrl()); + } finally { + lock.release(); + } + + if (orphans != null) { + try { + lock.acquire(); + orphans.internalAddChild(task); + } finally { + lock.release(); + } + if (delta != null) { + delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED)); + } + task.addParentContainer(orphans); + } else { + StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, + "Orphan container not found for: " + task.getRepositoryUrl())); + } + + // orphan all children as appropriate +// if (!task.isEmpty()) { +// for (AbstractTask child : task.getChildren()) { +// if (visitedContainers.contains(child)) { +// continue; +// } +// visitedContainers.add(child); +// addOrphan(child, delta, visitedContainers); +// } +// } + + } + + /** + * @since 2.2 + */ + private void removeOrphan(AbstractTask task, Set delta) { + + UnmatchedTaskContainer orphans; + try { + lock.acquire(); + orphans = repositoryOrphansMap.get(task.getRepositoryUrl()); + + if (orphans != null) { + if (orphans.contains(task.getHandleIdentifier())) { + orphans.internalRemoveChild(task); + if (delta != null) { + delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED)); + } + } + task.removeParentContainer(orphans); + } + } finally { + lock.release(); + } + } + + /** + * @API-3.0 make internal + * @since 2.2 + */ + public Set getOrphanContainers() { + try { + lock.acquire(); + return Collections.unmodifiableSet(new HashSet(repositoryOrphansMap.values())); + } finally { + lock.release(); + } + } + + /** + * @API-3.0 make internal + * @since 2.2 + */ + public UnmatchedTaskContainer getOrphanContainer(String repositoryUrl) { + try { + lock.acquire(); + return repositoryOrphansMap.get(repositoryUrl); + } finally { + lock.release(); + } + } + + /** + * @API-3.0 make internal + * @since 2.2 + */ + public void addOrphanContainer(UnmatchedTaskContainer orphanedTasksContainer) { + try { + lock.acquire(); + repositoryOrphansMap.put(orphanedTasksContainer.getRepositoryUrl(), orphanedTasksContainer); + } finally { + lock.release(); + } + } + + /** + * @API-3.0 make internal + * @since 2.2 + */ + public void removeOrphanContainer(String url) { + if (url != null && !url.equals(LocalRepositoryConnector.REPOSITORY_URL)) { + try { + lock.acquire(); + repositoryOrphansMap.remove(url); + } finally { + lock.release(); + } + } + } + + /** + * Public for testing. + */ + public void reset() { + try { + lock.acquire(); + tasks = new ConcurrentHashMap(); + + repositoryOrphansMap = new ConcurrentHashMap(); + + categories = new ConcurrentHashMap(); + queries = new ConcurrentHashMap(); + + defaultCategory = new UncategorizedTaskContainer(); + + activeTasks = new CopyOnWriteArrayList(); + lastLocalTaskId = 0; + categories.put(defaultCategory.getHandleIdentifier(), defaultCategory); + } finally { + lock.release(); + } + } + + /** + * Returns an ITask for each of the given handles + * + * @since 2.0 + */ + public Set getTasks(Set handles) { + HashSet result = new HashSet(); + Map tempTasks; + try { + lock.acquire(); + tempTasks = Collections.unmodifiableMap(tasks); + } finally { + lock.release(); + } + for (String handle : handles) { + AbstractTask tempTask = tempTasks.get(handle); + if (tempTask != null) { + result.add(tempTask); + } + } + return result; + } + + /** + * Add orphaned task to the task list + */ + public void addTask(AbstractTask task) throws IllegalArgumentException { + addTask(task, null); + } + + /** + * Precondition: {@code container} already exists in tasklist (be it a parent task, category, or query) If the + * parentContainer is null the task is considered an orphan and added to the appropriate repository's orphaned tasks + * container. + * + * @param task + * to be added + * @param container + * task container, query or parent task must not be null + */ + public void addTask(AbstractTask task, AbstractTaskContainer parentContainer) throws IllegalArgumentException { + moveTask(task, parentContainer); + /* task = (AbstractTask) getValidElement(task); + + if (parentContainer == null) { + addOrphan(task, null); + return; + } + + parentContainer = getValidElement(parentContainer); + + // At this point, task != null and exists in task list + // and parentContainer != null and exists in task list + + ISchedulingRule rule = task; + if (parentContainer != null) { + rule = MultiRule.combine(task, parentContainer); + } + try { + jobManager.beginRule(rule, new NullProgressMonitor()); + //progressMonitor.beginTask(name, 100); + try { + + if (parentContainer != null) { + // ensure that we don't have loops + if (task.contains(parentContainer.getHandleIdentifier())) { + parentContainer = null; + } + } + + // move new task into appropriate containers... + // precondition: task exists in task list + if (parentContainer != null) { + // ensure local tasks aren't duplicated in the uncategorized category when subtasks are enabled + if (task instanceof LocalTask && parentContainer instanceof LocalTask) { + + Set delta = new HashSet(); + delta.add(new TaskContainerDelta(parentContainer, TaskContainerDelta.Kind.CHANGED)); + + AbstractTaskCategory category = TaskCategory.getParentTaskCategory(task); + if (category != null) { + task.removeParentContainer(category); + category.internalRemoveChild(task); + delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.CHANGED)); + } else if (!task.getParentContainers().isEmpty()) { + + // local tasks should only have 1 parent + for (AbstractTaskContainer parent : task.getParentContainers()) { + if (parent != null) { + // and again here? + task.removeParentContainer(parent); + parent.internalRemoveChild(task); + delta.add(new TaskContainerDelta(parent, TaskContainerDelta.Kind.CHANGED)); + } + } + } + if (!delta.isEmpty()) { + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + } + + if (parentContainer instanceof AbstractTaskCategory) { + removeFromContainer(TaskCategory.getParentTaskCategory(task), task); + } + removeOrphan(task, null); + task.addParentContainer(parentContainer); + parentContainer.internalAddChild(task); + + } + + } finally { + //progressMonitor.done(); + } + + } finally { + jobManager.endRule(rule); + }*/ + } + + /** + * Task added if does not exist already. Ensures the element exists in the task list + * + * @throws IllegalAgumentException + * if null argument passed or element does not exist in task list + * @return element as passed in or instance from task list with same handle if exists + */ + private AbstractTaskContainer getValidElement(AbstractTaskContainer taskListElement) + throws IllegalArgumentException { + + if (taskListElement == null) { + throw new IllegalArgumentException("Argument can not be null"); + } + + AbstractTaskContainer result = null; + + if (taskListElement instanceof AbstractTask) { +// boolean isNew = false; + AbstractTask taskInTaskList; + try { + lock.acquire(); + // Access or modify data structure + + taskInTaskList = tasks.get(taskListElement.getHandleIdentifier()); + if (taskInTaskList == null) { + tasks.put(taskListElement.getHandleIdentifier(), (AbstractTask) taskListElement); + taskInTaskList = (AbstractTask) taskListElement; +// isNew = true; + } + result = taskInTaskList; + + } finally { + lock.release(); + } + +// if (isNew) { +// // NOTE: only called for newly-created tasks +// // TODO: REVIEW, call in separate thread? +// Set delta = new HashSet(); +// delta.add(new TaskContainerDelta(taskListElement, TaskContainerDelta.Kind.ADDED)); +//// if (parentContainer != null) { +//// delta.add(new TaskContainerDelta(parentContainer, TaskContainerDelta.Kind.CHANGED)); +//// } +// for (ITaskListChangeListener listener : changeListeners) { +// listener.containersChanged(delta); +// } +// } + } + if (taskListElement instanceof UncategorizedTaskContainer) { + result = defaultCategory; + } + if (taskListElement instanceof UnmatchedTaskContainer) { + try { + lock.acquire(); + UnmatchedTaskContainer container = repositoryOrphansMap.get(((UnmatchedTaskContainer) taskListElement).getRepositoryUrl()); + if (container != null) { + result = container; + } + } finally { + lock.release(); + } + } else if (taskListElement instanceof TaskCategory) { + try { + lock.acquire(); + AbstractTaskCategory category = categories.get(taskListElement.getHandleIdentifier()); + if (category != null) { + result = category; + } + } finally { + lock.release(); + } + } else if (taskListElement instanceof AbstractRepositoryQuery) { + try { + lock.acquire(); + AbstractRepositoryQuery query = queries.get(taskListElement.getHandleIdentifier()); + if (query != null) { + result = query; + } + } finally { + lock.release(); + } + } + + if (result == null) { + throw new IllegalArgumentException("Element " + taskListElement.getHandleIdentifier() + + " does not exist in the task list."); + } else { + return result; + } + + } + + /** + * @since 2.2 + */ + public void moveTask(AbstractTask task, AbstractTaskContainer container) { + + task = (AbstractTask) getValidElement(task); + + if (task instanceof LocalTask && container == null) { + container = defaultCategory; + } else if (container == null) { + addOrphan(task, null); + return; + } + + container = getValidElement(container); + + // task != null && exists in task list + // category exists and != null + + // ensure that we don't have loops + if (task.contains(container.getHandleIdentifier())) { + return; + } + + Set delta = new HashSet(); + + if (task instanceof LocalTask && !task.getParentContainers().isEmpty()) { + + // local tasks should only have 1 parent + for (AbstractTaskContainer parent : task.getParentContainers()) { + if (parent != null) { + task.removeParentContainer(parent); + parent.internalRemoveChild(task); + delta.add(new TaskContainerDelta(parent, TaskContainerDelta.Kind.CHANGED)); + } + } + } + + if (container instanceof AbstractTaskCategory) { + // Tasks can only be in one task category at a time + AbstractTaskCategory tempCat = TaskCategory.getParentTaskCategory(task); + if (tempCat != null && !tempCat.equals(container)) { + removeFromContainer(tempCat, task, delta); + } + } + if (!(container instanceof UnmatchedTaskContainer)) { + // If a task has a parent query/category/task it is no longer an orphan + removeOrphan(task, delta); + } + task.addParentContainer(container); + container.internalAddChild(task); + + delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.CHANGED)); + delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED)); + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + public void refactorRepositoryUrl(String oldRepositoryUrl, String newRepositoryUrl) { + Set delta = new HashSet(); + try { + lock.acquire(); + for (AbstractTask task : tasks.values()) { + if (oldRepositoryUrl.equals(RepositoryTaskHandleUtil.getRepositoryUrl(task.getHandleIdentifier()))) { + tasks.remove(task.getHandleIdentifier()); + task.setRepositoryUrl(newRepositoryUrl); + tasks.put(task.getHandleIdentifier(), task); + String taskUrl = task.getUrl(); + if (taskUrl != null && taskUrl.startsWith(oldRepositoryUrl)) { + task.setUrl(newRepositoryUrl + taskUrl.substring(oldRepositoryUrl.length())); + } + } + } + + for (AbstractRepositoryQuery query : queries.values()) { + if (query.getRepositoryUrl().equals(oldRepositoryUrl)) { + query.setRepositoryUrl(newRepositoryUrl); + delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.CHANGED)); + } + } + + for (UnmatchedTaskContainer orphans : repositoryOrphansMap.values()) { + if (orphans.getRepositoryUrl().equals(oldRepositoryUrl)) { + repositoryOrphansMap.remove(oldRepositoryUrl); + //categories.remove(orphans.getHandleIdentifier()); + orphans.setRepositoryUrl(newRepositoryUrl); + repositoryOrphansMap.put(newRepositoryUrl, orphans); + //categories.put(orphans.getHandleIdentifier(), orphans); + delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED)); + } + } + } finally { + lock.release(); + } + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + public void addCategory(TaskCategory category) throws IllegalArgumentException { + if (category == null) { + throw new IllegalArgumentException("Category cannot be null"); + } + try { + lock.acquire(); + categories.put(category.getHandleIdentifier(), category); + } finally { + lock.release(); + } + Set delta = new HashSet(); + delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.ADDED)); + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + /** + * @deprecated use removeFromContainer(AbstractTaskContainer category, AbstractTask task) + */ + @Deprecated + public void removeFromCategory(TaskCategory category, AbstractTask task) { + removeFromContainer(category, task); + } + + /** + * @deprecated removeFromContainer(AbstractTaskContainer category, AbstractTask task) + */ + @Deprecated + public void removeFromQuery(AbstractRepositoryQuery query, AbstractTask task) { + removeFromContainer(query, task); + } + + /** + * @since 3.0 + */ + public void removeFromContainer(AbstractTaskContainer container, AbstractTask task) { + Set delta = new HashSet(); + removeFromContainer(container, task, delta); + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + /** + * @Since 3.0 + */ + public void removeFromContainer(AbstractTaskContainer container, AbstractTask task, Set delta) { + if (container == null || task == null) { + return; + } + container.internalRemoveChild(task); + task.removeParentContainer(container); + addOrphan(task, delta); + delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.CHANGED)); + delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED)); + } + + public void removeFromQuery(AbstractRepositoryQuery repositoryQuery, Set tasks) { + // FIXME do a bulk remove + for (AbstractTask task : tasks) { + removeFromQuery(repositoryQuery, task); + } + } + + /** + * @deprecated + */ + @Deprecated + public void renameTask(AbstractTask task, String description) { + task.setSummary(description); + + Set delta = new HashSet(); + delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.CHANGED)); + + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + /** + * Use renameTask(..) for renaming tasks. + */ + public void renameContainer(AbstractTaskContainer container, String newDescription) { + Set delta = new HashSet(); + try { + lock.acquire(); + if (container instanceof AbstractTask) { + return; + } else if (!(container instanceof UnmatchedTaskContainer)) { + if (queries.remove(container.getHandleIdentifier()) != null) { + if (container instanceof AbstractTaskCategory) { + ((AbstractTaskCategory) container).setHandleIdentifier(newDescription); + } else if (container instanceof AbstractRepositoryQuery) { + ((AbstractRepositoryQuery) container).setHandleIdentifier(newDescription); + queries.put(((AbstractRepositoryQuery) container).getHandleIdentifier(), + ((AbstractRepositoryQuery) container)); + } + } else if (container instanceof TaskCategory + && categories.remove(container.getHandleIdentifier()) != null) { + ((TaskCategory) container).setHandleIdentifier(newDescription); + categories.put(((TaskCategory) container).getHandleIdentifier(), (TaskCategory) container); + } + } + } finally { + lock.release(); + } + // TODO: make this delta policy symmetrical with tasks + delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.REMOVED)); + delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.ADDED)); + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + public void addQuery(AbstractRepositoryQuery query) throws IllegalArgumentException { + if (query == null) { + throw new IllegalArgumentException("Query cannot be null"); + } + try { + lock.acquire(); + queries.put(query.getHandleIdentifier(), query); + } finally { + lock.release(); + } + Set delta = new HashSet(); + delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.ADDED)); + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + /** + * TODO: refactor around querying containers for their tasks + * + * Task is removed from all containers: root, archive, category, and orphan bin + * + * Currently subtasks are not deleted but rather are rather potentially orphaned + */ + public void deleteTask(AbstractTask task) { + //defaultCategory.internalRemoveChild(task); + Set delta = new HashSet(); + // Remove task from all parent containers + for (AbstractTaskContainer container : task.getParentContainers()) { + container.internalRemoveChild(task); + task.removeParentContainer(container); + } + + // Remove this task as a parent for all subtasks + // moving to orphanage as necessary + for (AbstractTask child : task.getChildren()) { + child.removeParentContainer(task); + addOrphan(child, delta); + } + task.clear(); + removeOrphan(task, delta); + try { + lock.acquire(); + tasks.remove(task.getHandleIdentifier()); + } finally { + lock.release(); + } + delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.REMOVED)); + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + public void deleteCategory(AbstractTaskCategory category) { + Set delta = new HashSet(); + try { + lock.acquire(); + categories.remove(category.getHandleIdentifier()); + } finally { + lock.release(); + } + for (AbstractTask task : category.getChildren()) { + task.removeParentContainer(category); + addOrphan(task, delta); + } + + delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.REMOVED)); + + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + public void deleteQuery(AbstractRepositoryQuery query) { + Set delta = new HashSet(); + try { + lock.acquire(); + queries.remove(query.getHandleIdentifier()); + } finally { + lock.release(); + } + for (AbstractTask task : query.getChildren()) { + task.removeParentContainer(query); + addOrphan(task, delta); + } + + delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.REMOVED)); + for (ITaskListChangeListener listener : changeListeners) { + listener.containersChanged(delta); + } + } + + /** + * @param task + * @param complete + * @deprecated use AbstractTask.setCompletionDate() and notify appropriately + */ + @Deprecated + public void markComplete(AbstractTask task, boolean complete) { + task.setCompleted(complete); + + Set delta = new HashSet(); + delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.CHANGED)); + for (ITaskListChangeListener listener : new ArrayList(changeListeners)) { + listener.containersChanged(delta); + } + } + + public void addChangeListener(ITaskListChangeListener listener) { + changeListeners.add(listener); + } + + public void removeChangeListener(ITaskListChangeListener listener) { + changeListeners.remove(listener); + } + + @Deprecated + public void setActive(AbstractTask task, boolean active) { + task.setActive(active); + try { + lock.acquire(); + if (active && !activeTasks.contains(task)) { + activeTasks.add(task); + } else if (!active) { + activeTasks.remove(task); + } + } finally { + lock.release(); + } + } + + /** + * For normal user operation getActiveTask() should be used instead. + */ + public List getActiveTasks() { + try { + lock.acquire(); + return Collections.unmodifiableList(activeTasks); + } finally { + lock.release(); + } + } + + /** + * @return First in set of all active tasks. Normal user operations only supports a single active task. + */ + public AbstractTask getActiveTask() { + try { + lock.acquire(); + if (activeTasks.size() > 0) { + return activeTasks.get(0); + } else { + return null; + } + } finally { + lock.release(); + } + } + + public Set getCategories() { + try { + lock.acquire(); + return Collections.unmodifiableSet(new HashSet(categories.values())); + } finally { + lock.release(); + } + } + + /** + * @deprecated + * @API 3.0: remove + */ + @Deprecated + public List getUserCategories() { + List included = new ArrayList(); + try { + lock.acquire(); + for (AbstractTaskCategory category : categories.values()) { + included.add(category); + } + } finally { + lock.release(); + } + return included; + } + + public Set getQueries() { + try { + lock.acquire(); + return Collections.unmodifiableSet(new HashSet(queries.values())); + } finally { + lock.release(); + } + } + + public Set getRootElements() { + Set roots = new HashSet(); + roots.add(defaultCategory); + try { + lock.acquire(); + for (AbstractTaskCategory cat : categories.values()) { + roots.add(cat); + } + for (AbstractRepositoryQuery query : queries.values()) { + roots.add(query); + } + for (UnmatchedTaskContainer orphanContainer : repositoryOrphansMap.values()) { + roots.add(orphanContainer); + } + } finally { + lock.release(); + } + return roots; + } + + public Collection getAllTasks() { + try { + lock.acquire(); + return Collections.unmodifiableCollection(tasks.values()); + } finally { + lock.release(); + } + } + + public Set getTaskContainers() { + Set containers = new HashSet(); + try { + lock.acquire(); + for (AbstractTaskCategory container : categories.values()) { + if (container instanceof TaskCategory) { + containers.add(container); + } + } + } finally { + lock.release(); + } + return containers; + } + + /** + * API 3.0: remove + */ + public AbstractRepositoryQuery getQueryForHandle(String handle) { + if (handle == null) { + return null; + } + try { + lock.acquire(); + for (AbstractRepositoryQuery query : queries.values()) { + if (query.contains(handle)) { + return query; + } + } + } finally { + lock.release(); + } + return null; + } + + public boolean isEmpty() { + boolean isEmpty = getCategories().size() == 1 && getCategories().contains(defaultCategory); + return getAllTasks().size() == 0 && isEmpty && getQueries().size() == 0; + } + + /** + * TODO: consider removing, if everything becomes a repository task + * + * @return null if no such task. + */ + public AbstractTask getTask(String handleIdentifier) { + if (handleIdentifier == null) { + return null; + } else { + try { + lock.acquire(); + return tasks.get(handleIdentifier); + } finally { + lock.release(); + } + } + } + + /** + * @since 2.0 + */ + public AbstractTask getTask(String repositoryUrl, String taskId) { + if (!RepositoryTaskHandleUtil.isValidTaskId(taskId)) { + return null; + } + + String handle = RepositoryTaskHandleUtil.getHandle(repositoryUrl, taskId); + AbstractTask task = getTask(handle); + return task; + } + + /** + * Searches for a task whose URL matches + * + * @return first task with a matching URL. + * @since 2.0 + */ + public AbstractTask getRepositoryTask(String taskUrl) { + try { + lock.acquire(); + for (AbstractTask currTask : tasks.values()) { + String currUrl = currTask.getUrl(); + if (currUrl != null && !currUrl.equals("") && currUrl.equals(taskUrl)) { + return currTask; + } + } + } finally { + lock.release(); + } + return null; + } + + /** + * Searches for a task whose key matches. + * + * @return first task with a key, null if no matching task is found + * @since 2.0 + */ + public AbstractTask getTaskByKey(String repositoryUrl, String taskKey) { + try { + lock.acquire(); + for (AbstractTask task : tasks.values()) { + String currentTaskKey = task.getTaskKey(); + if (currentTaskKey != null && currentTaskKey.equals(taskKey) + && task.getRepositoryUrl().equals(repositoryUrl)) { + return task; + } + } + } finally { + lock.release(); + } + return null; + } + + public AbstractTaskCategory getContainerForHandle(String categoryHandle) { + try { + lock.acquire(); + for (AbstractTaskCategory cat : categories.values()) { + if (cat != null) { + if (cat.getHandleIdentifier().equals(categoryHandle)) { + return cat; + } + } + } + } finally { + lock.release(); + } + return null; + } + + public AbstractTaskCategory getDefaultCategory() { + return defaultCategory; + } + + /** + * @since 2.3 + * @API 3.0 move to AbstractRepositoryQuery and make static? + */ + public Set getParentQueries(AbstractTask task) { + Set parentQueries = new HashSet(); + for (AbstractTaskContainer container : task.getParentContainers()) { + if (container instanceof AbstractRepositoryQuery) { + parentQueries.add((AbstractRepositoryQuery) container); + } + } + return parentQueries; + } + + /** + * if handle == null or no queries found an empty set is returned + * + * @API 3.0: remove + */ + public Set getQueriesForHandle(String handle) { + if (handle == null) { + return Collections.emptySet(); + } + Set queriesForHandle = new HashSet(); + AbstractTask tempTask; + try { + lock.acquire(); + tempTask = tasks.get(handle); + } finally { + lock.release(); + } + if (tempTask != null) { + queriesForHandle = getParentQueries(tempTask); + } + + return queriesForHandle; + } + + /** + * return all queries for the given repository url + */ + public Set getRepositoryQueries(String repositoryUrl) { + Set repositoryQueries = new HashSet(); + if (repositoryUrl != null) { + try { + lock.acquire(); + for (AbstractRepositoryQuery query : queries.values()) { + if (query.getRepositoryUrl().equals(repositoryUrl)) { + repositoryQueries.add(query); + } + } + } finally { + lock.release(); + } + } + return repositoryQueries; + } + + /** + * return all tasks for the given repository url + * + * API-3.0: add a parameter for the kind + */ + public Set getRepositoryTasks(String repositoryUrl) { + Set repositoryTasks = new HashSet(); + if (repositoryUrl != null) { + try { + lock.acquire(); + for (AbstractTask task : tasks.values()) { + if (task.getRepositoryUrl().equals(repositoryUrl)) { + repositoryTasks.add(task); + } + } + } finally { + lock.release(); + } + } + return repositoryTasks; + } + + /** + * Exposed for unit testing + * + * @return unmodifiable collection of ITaskActivityListeners + */ + public Set getChangeListeners() { + try { + lock.acquire(); + return Collections.unmodifiableSet(changeListeners); + } finally { + lock.release(); + } + + } + + /** + * @param task + * @param content + * true if the content for the task (e.g. repository task data) has changed + */ + public void notifyTaskChanged(AbstractTask task, boolean content) { + for (ITaskListChangeListener listener : new ArrayList(changeListeners)) { + try { + Set delta = new HashSet(); + TaskContainerDelta.Kind kind; + if (content) { + kind = TaskContainerDelta.Kind.CONTENT; + } else { + kind = TaskContainerDelta.Kind.CHANGED; + } + delta.add(new TaskContainerDelta(task, kind)); + listener.containersChanged(delta); + } catch (Throwable t) { + StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, "Notification failed for: " + + listener, t)); + } + } + } + + public void notifyContainersUpdated(Set containers) { + Set delta; + if (containers == null) { + delta = new HashSet(); + delta.add(new TaskContainerDelta(null, TaskContainerDelta.Kind.ROOT)); + } else { + delta = new HashSet(); + for (AbstractTaskContainer abstractTaskContainer : containers) { + delta.add(new TaskContainerDelta(abstractTaskContainer, TaskContainerDelta.Kind.CHANGED)); + } + } + for (ITaskListChangeListener listener : new ArrayList(changeListeners)) { + try { + listener.containersChanged(delta); + } catch (Throwable t) { + StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, "Notification failed for: " + + listener, t)); + } + } + } + + public int getNextLocalTaskId() { + try { + lock.acquire(); + return ++lastLocalTaskId; + } finally { + lock.release(); + } + } + + public void setLastLocalTaskId(int lastTaskNum) { + try { + lock.acquire(); + this.lastLocalTaskId = lastTaskNum; + } finally { + lock.release(); + } + } + + /** For tasklist persistence. Use getNextTaskNum for task construction */ + public int getLastLocalTaskId() { + try { + lock.acquire(); + return lastLocalTaskId; + } finally { + lock.release(); + } + } + + /** Note: use getNextTaskNum for new task construction */ + public int findLargestTaskId() { + int max = 0; + try { + lock.acquire(); + max = Math.max(largestTaskIdHelper(tasks.values(), 0, 0), max); + } finally { + lock.release(); + } + for (AbstractTaskCategory cat : getTaskContainers()) { + max = Math.max(largestTaskIdHelper(cat.getChildren(), 0, 0), max); + } + return max; + } + + /** + * Maxes out at 20 recursions for safety. + */ + private int largestTaskIdHelper(Collection tasks, int lastMax, int depth) { + if (depth >= 20) { + return lastMax; + } else { + depth++; + int ihandle = 0; + int max = 0; + for (AbstractTask task : tasks) { + if (task instanceof LocalTask) { + String string = task.getHandleIdentifier().substring( + task.getHandleIdentifier().lastIndexOf('-') + 1, task.getHandleIdentifier().length()); + try { + ihandle = Integer.parseInt(string); + } catch (NumberFormatException nfe) { + // ignore + } + max = Math.max(ihandle, max); + ihandle = largestTaskIdHelper(task.getChildren(), max, depth); + max = Math.max(ihandle, max); + } + } + return max; + } + } + + /** + * @since 3.0 + */ + public boolean contains(ISchedulingRule rule) { + return isConflicting(rule); + } + + /** + * @since 3.0 + */ + public boolean isConflicting(ISchedulingRule rule) { + return rule instanceof TaskList || rule instanceof AbstractTaskContainer; + } + +// /** +// * @deprecated use moveTask +// */ +// @Deprecated +// public void moveToContainer(AbstractTask task, AbstractTaskCategory container) { +// try { +// lock.acquire(); +// if (!tasks.containsKey(task.getHandleIdentifier())) { +// tasks.put(task.getHandleIdentifier(), task); +// } +// } finally { +// lock.release(); +// } +// Set delta = new HashSet(); +// delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED)); +// +// Set currentContainers = task.getParentContainers(); +// for (AbstractTaskContainer taskContainer : currentContainers) { +// if (taskContainer instanceof AbstractTaskCategory) { +// if (!(taskContainer instanceof UnmatchedTaskContainer)) { +// (taskContainer).internalRemoveChild(task); +// } +//// if (!(taskContainer instanceof TaskArchive)) { +//// (taskContainer).internalRemoveChild(task); +//// } +// task.removeParentContainer(taskContainer); +// delta.add(new TaskContainerDelta(taskContainer, TaskContainerDelta.Kind.CHANGED)); +// } +// } +// if (container != null) { +// internalAddTask(task, container); +// delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED)); +// if (!(container instanceof UnmatchedTaskContainer)) { +// removeOrphan(task, delta); +// } +//// if (archiveContainer.contains(task.getHandleIdentifier())) { +//// archiveContainer.internalRemoveChild(task); +//// delta.add(new TaskContainerDelta(archiveContainer, TaskContainerDelta.Kind.CHANGED)); +//// } +// } else { +// internalAddTask(task, null); +// } +// for (ITaskListChangeListener listener : changeListeners) { +// listener.containersChanged(delta); +// } +// } + +// /** +// * +// * @API-3.0 review/deprecate, use addTask directly? +// * +// * @since 2. +// * @deprecated +// */ +// @Deprecated +// public final void insertTask(AbstractTask task, AbstractTaskCategory legacyCategory, AbstractTask parent) { +// if (task.getCategoryHandle().length() > 0) { +// AbstractTaskCategory category = this.getContainerForHandle(task.getCategoryHandle()); +// +// if (category != null) { +// this.internalAddTask(task, category); +// } else if (parent == null) { +// this.internalAddRootTask(task); +// } +// } else if (legacyCategory != null && !(legacyCategory instanceof TaskArchive) +// && getCategories().contains(legacyCategory)) { +// task.addParentContainer(legacyCategory); +// legacyCategory.internalAddChild(task); +// } else { +// this.internalAddTask(task, null); +// } +// +// this.setActive(task, task.isActive()); +// } +// /** +// * @deprecated +// */ +// @Deprecated +// public void internalAddCategory(TaskCategory category) { +// try { +// lock.acquire(); +// categories.put(category.getHandleIdentifier(), category); +// } finally { +// lock.release(); +// } +// } + + /** + * @deprecated + */ +// @Deprecated +// public void internalAddTask(AbstractTask task, AbstractTaskCategory container) { +// internalAddTask(task, (AbstractTaskContainer) container); +// //tasks.put(task.getHandleIdentifier(), task); +// if (container != null) { +// tasks.put(task.getHandleIdentifier(), task); +// container.internalAddChild(task); +// if (container instanceof TaskCategory || container instanceof OrphanedTasksContainer) { +// task.addParentContainer(container); +// } +// } else { +// if (task.getLastReadTimeStamp() != null) { +// // any unread task (hit) that is an orphan is discarded +// tasks.put(task.getHandleIdentifier(), task); +// addOrphan(task, null); +// } +//// defaultCategory.internalAddChild(task); +//// task.addParentContainer(defaultCategory); +// } +// } +// /** +// * @deprecated +// */ +// @Deprecated +// private void internalAddTask(AbstractTask task, AbstractTaskContainer container) { +// try { +// lock.acquire(); +// tasks.put(task.getHandleIdentifier(), task); +// } finally { +// lock.release(); +// } +// if (container != null) { +// container.internalAddChild(task); +// if (container instanceof TaskCategory || container instanceof UnmatchedTaskContainer +// || container instanceof UncategorizedTaskContainer) { +// task.addParentContainer(container); +// } +// } else { +// //if (task.getLastReadTimeStamp() != null) { +// // any unread task (hit) that is an orphan is discarded +// addOrphan(task, null); +// //} +//// defaultCategory.internalAddChild(task); +//// task.addParentContainer(defaultCategory); +// } +// } +// +// /** +// * @API-3.0 remove +// * @deprecated +// */ +// @Deprecated +// public void internalAddRootTask(AbstractTask task) { +// internalAddTask(task, null); +// } +// /** +// * @deprecated +// */ +// @Deprecated +// public void internalAddQuery(AbstractRepositoryQuery query) { +// try { +// lock.acquire(); +// queries.put(query.getHandleIdentifier(), query); +// } finally { +// lock.release(); +// } +// } +} diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskRepositoryManager.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskRepositoryManager.java index ab7182367..e8fd3f4d6 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskRepositoryManager.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskRepositoryManager.java @@ -26,7 +26,6 @@ import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector; import org.eclipse.mylyn.tasks.core.AbstractTask; import org.eclipse.mylyn.tasks.core.ITaskRepositoryListener; import org.eclipse.mylyn.tasks.core.ITaskRepositoryManager; -import org.eclipse.mylyn.tasks.core.TaskList; import org.eclipse.mylyn.tasks.core.TaskRepository; /** diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/RepositorySynchronizationManager.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/RepositorySynchronizationManager.java index 193aaa327..b83121c4c 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/RepositorySynchronizationManager.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/RepositorySynchronizationManager.java @@ -15,9 +15,9 @@ import java.util.Set; import org.eclipse.core.runtime.Assert; import org.eclipse.mylyn.internal.tasks.core.TaskDataManager; import org.eclipse.mylyn.tasks.core.AbstractTask; +import org.eclipse.mylyn.tasks.core.ITaskList; import org.eclipse.mylyn.tasks.core.RepositoryTaskAttribute; import org.eclipse.mylyn.tasks.core.RepositoryTaskData; -import org.eclipse.mylyn.tasks.core.TaskList; import org.eclipse.mylyn.tasks.core.AbstractTask.RepositoryTaskSyncState; import org.eclipse.mylyn.tasks.core.sync.IRepositorySynchronizationManager; @@ -32,9 +32,9 @@ public final class RepositorySynchronizationManager implements IRepositorySynchr private final TaskDataManager taskDataManager; - private final TaskList taskList; + private final ITaskList taskList; - public RepositorySynchronizationManager(TaskDataManager taskDataManager, TaskList taskList) { + public RepositorySynchronizationManager(TaskDataManager taskDataManager, ITaskList taskList) { this.taskDataManager = taskDataManager; this.taskList = taskList; } diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeAllTasksJob.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeAllTasksJob.java index 1ec457785..f59f2b80c 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeAllTasksJob.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeAllTasksJob.java @@ -19,8 +19,8 @@ import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.SubProgressMonitor; import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector; import org.eclipse.mylyn.tasks.core.AbstractTask; +import org.eclipse.mylyn.tasks.core.ITaskList; import org.eclipse.mylyn.tasks.core.ITaskRepositoryManager; -import org.eclipse.mylyn.tasks.core.TaskList; import org.eclipse.mylyn.tasks.core.TaskRepository; import org.eclipse.mylyn.tasks.core.sync.IRepositorySynchronizationManager; import org.eclipse.mylyn.tasks.core.sync.SynchronizationJob; @@ -34,13 +34,13 @@ public class SynchronizeAllTasksJob extends SynchronizationJob { private final IRepositorySynchronizationManager synchronizationManager; - private final TaskList taskList; + private final ITaskList taskList; private final Set tasks; private final ITaskRepositoryManager repositoryManager; - public SynchronizeAllTasksJob(TaskList taskList, IRepositorySynchronizationManager synchronizationManager, + public SynchronizeAllTasksJob(ITaskList taskList, IRepositorySynchronizationManager synchronizationManager, ITaskRepositoryManager repositoryManager, AbstractRepositoryConnector connector, Set tasks) { super("Synchronizing Tasks (" + tasks.size() + " tasks)"); this.taskList = taskList; diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java index b5c3efb4f..cbf3426f3 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java @@ -22,13 +22,13 @@ import org.eclipse.core.runtime.SubProgressMonitor; import org.eclipse.core.runtime.jobs.ISchedulingRule; import org.eclipse.core.runtime.jobs.Job; import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants; +import org.eclipse.mylyn.internal.tasks.core.TaskList; import org.eclipse.mylyn.monitor.core.DateUtil; import org.eclipse.mylyn.monitor.core.StatusHandler; import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector; import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery; import org.eclipse.mylyn.tasks.core.AbstractTask; import org.eclipse.mylyn.tasks.core.RepositoryTaskData; -import org.eclipse.mylyn.tasks.core.TaskList; import org.eclipse.mylyn.tasks.core.TaskRepository; import org.eclipse.mylyn.tasks.core.AbstractTask.RepositoryTaskSyncState; import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataCollector; diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeRepositoriesJob.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeRepositoriesJob.java index 7be844e88..aaf9a3c82 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeRepositoriesJob.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeRepositoriesJob.java @@ -17,11 +17,11 @@ import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.SubProgressMonitor; import org.eclipse.core.runtime.jobs.Job; import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants; +import org.eclipse.mylyn.internal.tasks.core.TaskList; import org.eclipse.mylyn.monitor.core.StatusHandler; import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector; import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery; import org.eclipse.mylyn.tasks.core.ITaskRepositoryManager; -import org.eclipse.mylyn.tasks.core.TaskList; import org.eclipse.mylyn.tasks.core.TaskRepository; import org.eclipse.mylyn.tasks.core.sync.IRepositorySynchronizationManager; import org.eclipse.mylyn.tasks.core.sync.SynchronizationJob; diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java index a9f888bb3..de2dc547c 100644 --- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java +++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java @@ -24,8 +24,8 @@ import org.eclipse.mylyn.monitor.core.StatusHandler; import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector; import org.eclipse.mylyn.tasks.core.AbstractTask; import org.eclipse.mylyn.tasks.core.AbstractTaskDataHandler; +import org.eclipse.mylyn.tasks.core.ITaskList; import org.eclipse.mylyn.tasks.core.RepositoryTaskData; -import org.eclipse.mylyn.tasks.core.TaskList; import org.eclipse.mylyn.tasks.core.TaskRepository; import org.eclipse.mylyn.tasks.core.AbstractTask.RepositoryTaskSyncState; import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataCollector; @@ -46,13 +46,13 @@ public class SynchronizeTasksJob extends SynchronizationJob { private final AbstractTaskDataHandler taskDataHandler; - private final TaskList taskList; + private final ITaskList taskList; private final TaskRepository taskRepository; private final Set tasks; - public SynchronizeTasksJob(TaskList taskList, IRepositorySynchronizationManager synchronizationManager, + public SynchronizeTasksJob(ITaskList taskList, IRepositorySynchronizationManager synchronizationManager, AbstractRepositoryConnector connector, TaskRepository taskRepository, Set tasks) { super("Synchronizing Tasks (" + tasks.size() + " tasks)"); this.taskList = taskList; -- cgit v1.2.3