Package: GroupDependencyTask

GroupDependencyTask

name	instruction	branch	complexity	line	method
GroupDependencyTask(TaskExecutor)	M: 0 C: 9 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 3 100%	M: 0 C: 1 100%
addDependency(DependencyTask)	M: 0 C: 19 100%	M: 0 C: 2 100%	M: 0 C: 2 100%	M: 0 C: 6 100%	M: 0 C: 1 100%
addMember(DependencyTask)	M: 8 C: 32 80%	M: 2 C: 4 67%	M: 2 C: 2 50%	M: 3 C: 9 75%	M: 0 C: 1 100%
addMembers(DependencyTask[])	M: 0 C: 20 100%	M: 0 C: 2 100%	M: 0 C: 2 100%	M: 0 C: 3 100%	M: 0 C: 1 100%
containsTransitive(DependencyTask)	M: 2 C: 18 90%	M: 1 C: 3 75%	M: 1 C: 2 67%	M: 1 C: 5 83%	M: 0 C: 1 100%
create(TaskExecutor)	M: 0 C: 5 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
doWork()	M: 0 C: 4 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%

Coverage

1: package de.fhdw.wtf.common.task;
2:
3: import java.util.ArrayList;
4: import java.util.Collection;
5: import java.util.Iterator;
6:
7: import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
8: import de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException;
9: import de.fhdw.wtf.common.task.result.OKTaskResult;
10: import de.fhdw.wtf.common.task.result.TaskResult;
11:
12: /**
13: * A GroupDependencyTask groups multiple member tasks to a seperate unit. It may as well have dependencies and be a
14: * dependency for others.
15: *
16: */
17: public class GroupDependencyTask extends DependencyTask {
18:         
19:         /**
20:          * Members participating in this group.
21:          */
22:         private final Collection<DependencyTask> members;
23:         
24:         /**
25:          * Constructor of {@link GroupDependencyTask}.
26:          *
27:          * @param taskmanager
28:          * taskmanager
29:          */
30:         public GroupDependencyTask(final TaskExecutor taskmanager) {
31:                 super(taskmanager);
32:                 this.members = new ArrayList<>();
33:         }
34:         
35:         /**
36:          * Creates a {@link GroupDependencyTask}-Object.
37:          *
38:          * @param taskmanager
39:          * taskmanager
40:          * @return The {@link GroupDependencyTask}-Object.
41:          */
42:         public static GroupDependencyTask create(final TaskExecutor taskmanager) {
43:                 return new GroupDependencyTask(taskmanager);
44:         }
45:         
46:         /**
47:          * Adds this task as member of this group.
48:          *
49:          * @param t
50:          * new group member
51:          * @throws CyclicPartDefinitionException
52:          * when cycles would arise
53:          */
54:         public void addMember(final DependencyTask t) throws CyclicPartDefinitionException {
55:•                if (this.contains(t)) {
56:                         throw CyclicPartDefinitionException.create();
57:                 } else {
58:                         try {
59:                                 super.addDependency(t);
60:                                 this.members.add(t);
61:                                 final Iterator<DependencyTask> i = this.getDependencies().getDependencies().iterator();
62:•                                while (i.hasNext()) {
63:                                         final DependencyTask current = i.next();
64:•                                        if (!this.members.contains(current)) {
65:                                                 t.addDependency(current);
66:                                         }
67:                                 }
68:                         } catch (final CyclicDependencyException e) {
69:                                 throw CyclicPartDefinitionException.create();
70:                         }
71:                 }
72:         }
73:         
74:         /**
75:          * Adds all tasks as member of this group task individually.
76:          *
77:          * @param newMembers
78:          * list of independent multiple new members
79:          * @throws CyclicPartDefinitionException
80:          * when cycles would arise
81:          * @see {@link #addMember(DependencyTask)}
82:          */
83:         public void addMembers(final DependencyTask... newMembers) throws CyclicPartDefinitionException {
84:•                for (final DependencyTask newMember : newMembers) {
85:                         this.addMember(newMember);
86:                 }
87:         }
88:         
89:         @Override
90:         public void addDependency(final DependencyTask a) throws CyclicDependencyException {
91:                 final Iterator<DependencyTask> i = this.members.iterator();
92:•                while (i.hasNext()) {
93:                         final DependencyTask current = i.next();
94:                         current.addDependency(a);
95:                 }
96:                 super.addDependency(a);
97:         }
98:         
99:         @Override
100:         public boolean containsTransitive(final DependencyTask a) {
101:                 final Iterator<DependencyTask> i = this.members.iterator();
102:•                while (i.hasNext()) {
103:                         final DependencyTask current = i.next();
104:•                        if (current.contains(a)) {
105:                                 return true;
106:                         }
107:                 }
108:                 return false;
109:         }
110:         
111:         @Override
112:         public TaskResult doWork() {
113:                 return new OKTaskResult();
114:         }
115:         
116: }