Esempio n. 1
0
        public bool AddTaskRelation(int taskId1, TaskRelation.RelationType relationType, int taskId2)
        {
            SimulationTask task1, task2;

            return(base.TryGetValue(taskId1, out task1) && base.TryGetValue(taskId2, out task2) &&
                   AddTaskRelation(task1, relationType, task2));
        }
Esempio n. 2
0
        public void UpdateTaskRelations(SimulationTask task, TaskRelation.RelationType relationType, IEnumerable <int> taskIds)
        {
            if (task == null)
            {
                return;
            }
            switch (relationType)
            {
            case TaskRelation.RelationType.Parallel:
                task.ParallelTasks.Remove(task.Id);
                foreach (var task2 in task.ParallelTasks.Values)
                {
                    task2.ParallelTasks.Remove(task.Id);
                    foreach (var taskId3 in taskIds)
                    {
                        task2.ParallelTasks.Remove(taskId3);
                    }
                }
                task.ParallelTasks.Clear();
                foreach (var taskId3 in taskIds)
                {
                    SimulationTask task3;
                    if (base.TryGetValue(taskId3, out task3))
                    {
                        task3.ParallelTasks.Clear();
                    }
                }
                break;

            case TaskRelation.RelationType.Slave:
                task.SlaveTasks.Remove(task.Id);
                foreach (var task2 in task.SlaveTasks.Values)
                {
                    task2.MasterTasks.Remove(task.Id);
                }
                task.SlaveTasks.Clear();
                break;

            case TaskRelation.RelationType.Master:
                task.MasterTasks.Remove(task.Id);
                foreach (var task2 in task.MasterTasks.Values)
                {
                    task2.SlaveTasks.Remove(task.Id);
                }
                task.MasterTasks.Clear();
                break;

            default:
                return;
            }
            foreach (var taskId2 in taskIds)
            {
                AddTaskRelation(task, relationType, taskId2);
            }
        }
Esempio n. 3
0
 public TaskRelationTemp(SimulationTask task1, TaskRelation.RelationType relation, int taskId2)
 {
     this.task1    = task1;
     this.relation = relation;
     this.taskId2  = taskId2;
 }
Esempio n. 4
0
        public static bool AddTaskRelation(SimulationTask task1, TaskRelation.RelationType relationType, SimulationTask task2)
        {
            if ((task1 == null) || (task2 == null))
            {
                return(false);
            }
            switch (relationType)
            {
            case TaskRelation.RelationType.Parallel:                            //Make a complete directed graph
                if (task1.Id == task2.Id)
                {
                    return(false);
                }
                foreach (var task3 in task1.ParallelTasks.Values)
                {
                    foreach (var task4 in task2.ParallelTasks.Values)
                    {
                        if (task3.Id != task4.Id)
                        {
                            if (!task3.ParallelTasks.ContainsKey(task4.Id))
                            {
                                task3.ParallelTasks.Add(task4.Id, task4);
                            }
                            if (!task4.ParallelTasks.ContainsKey(task3.Id))
                            {
                                task4.ParallelTasks.Add(task3.Id, task3);
                            }
                        }
                    }
                }
                foreach (var task3 in task1.ParallelTasks.Values)
                {
                    if (task3.Id != task2.Id)
                    {
                        if (!task2.ParallelTasks.ContainsKey(task3.Id))
                        {
                            task2.ParallelTasks.Add(task3.Id, task3);
                        }
                        if (!task3.ParallelTasks.ContainsKey(task2.Id))
                        {
                            task3.ParallelTasks.Add(task2.Id, task2);
                        }
                    }
                }
                foreach (var task4 in task2.ParallelTasks.Values)
                {
                    if (task4.Id != task1.Id)
                    {
                        if (!task1.ParallelTasks.ContainsKey(task4.Id))
                        {
                            task1.ParallelTasks.Add(task4.Id, task4);
                        }
                        if (!task4.ParallelTasks.ContainsKey(task1.Id))
                        {
                            task4.ParallelTasks.Add(task1.Id, task1);
                        }
                    }
                }
                if (!task1.ParallelTasks.ContainsKey(task2.Id))
                {
                    task1.ParallelTasks.Add(task2.Id, task2);
                }
                if (!task2.ParallelTasks.ContainsKey(task1.Id))
                {
                    task2.ParallelTasks.Add(task1.Id, task1);
                }
                return(true);

            case TaskRelation.RelationType.Slave:
                if ((task1.Id == task2.Id) || (task1.MasterTasks.ContainsKey(task2.Id)) ||
                    (task2.SlaveTasks.ContainsKey(task1.Id)))
                {
                    return(false);
                }
                if (!task1.SlaveTasks.ContainsKey(task2.Id))
                {
                    task1.SlaveTasks.Add(task2.Id, task2);
                }
                if (!task2.MasterTasks.ContainsKey(task1.Id))
                {
                    task2.MasterTasks.Add(task1.Id, task1);
                }
                return(true);

            case TaskRelation.RelationType.Master:
                if ((task1.Id == task2.Id) || (task1.SlaveTasks.ContainsKey(task2.Id)) ||
                    (task2.MasterTasks.ContainsKey(task1.Id)))
                {
                    return(false);
                }
                if (!task1.MasterTasks.ContainsKey(task2.Id))
                {
                    task1.MasterTasks.Add(task2.Id, task2);
                }
                if (!task2.SlaveTasks.ContainsKey(task1.Id))
                {
                    task2.SlaveTasks.Add(task1.Id, task1);
                }
                return(true);

            case TaskRelation.RelationType.None:
            default:
                return(false);
            }

            /*else
             * {
             *      duplicate = task1.Relations.FirstOrDefault(tr => (tr.Task2.Id == taskId2) && (tr.Relation == relationType)).Valid;
             *      if ((!duplicate) && taskRelation.Valid)
             *      {
             *              task1.Relations.Add(taskRelation);
             *              task2.Relations.Add(taskRelation);
             *      }
             * }*/
        }