Debian Codegraph @

src/plugins/schedulers/tj/taskjuggler/TaskList.cpp

raw
1 /*
2 * TaskList.cpp - TaskJuggler
3 *
4 * SPDX-FileCopyrightText: 2001, 2002, 2003, 2004 Chris Schlaeger <[email protected]>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of version 2 of the GNU General Public License as
8 * published by the Free Software Foundation.
9 *
10 * $Id$
11 */
12 // clazy:excludeall=qstring-arg
13 #include "TaskList.h"
14 #include "Resource.h"
15
16 namespace TJ
17 {
18
19 Task*
20 TaskList::getTask(const QString& id) const
21 {
22 for (TaskListIterator tli(*this); *tli != nullptr; ++tli)
23 if ((*tli)->getId() == id)
24 return *tli;
25
26 return nullptr;
27 }
28
29 bool
30 TaskList::isSupportedSortingCriteria(int sc)
31 {
32 switch (sc & 0xFFFF)
33 {
34 case TreeMode:
35 case StartUp:
36 case StartDown:
37 case EndUp:
38 case EndDown:
39 case StatusUp:
40 case StatusDown:
41 case CompletedUp:
42 case CompletedDown:
43 case PrioUp:
44 case PrioDown:
45 case ResponsibleUp:
46 case ResponsibleDown:
47 case CriticalnessUp:
48 case CriticalnessDown:
49 case PathCriticalnessUp:
50 case PathCriticalnessDown:
51 return true;
52 default:
53 return CoreAttributesList::isSupportedSortingCriteria(sc);
54 }
55 }
56
57 int
58 TaskList::compareItemsLevel(CoreAttributes* c1, CoreAttributes* c2, int level)
59 {
60 Task* t1 = static_cast<Task*>(c1);
61 Task* t2 = static_cast<Task*>(c2);
62
63 if (level < 0 || level >= maxSortingLevel)
64 return -1;
65
66 switch (sorting[level])
67 {
68 case TreeMode:
69 if (level == 0)
70 return compareTreeItemsT(this, t1, t2);
71 else
72 return t1->getSequenceNo() == t2->getSequenceNo() ? 0 :
73 t1->getSequenceNo() < t2->getSequenceNo() ? -1 : 1;
74 case StartUp:
75 return t1->scenarios[sortScenario].start ==
76 t2->scenarios[sortScenario].start ? 0 :
77 t1->scenarios[sortScenario].start <
78 t2->scenarios[sortScenario].start ? -1 : 1;
79 case StartDown:
80 return t1->scenarios[sortScenario].start ==
81 t2->scenarios[sortScenario].start ? 0 :
82 t1->scenarios[sortScenario].start >
83 t2->scenarios[sortScenario].start ? -1 : 1;
84 case EndUp:
85 return t1->scenarios[sortScenario].end ==
86 t2->scenarios[sortScenario].end ? 0 :
87 t1->scenarios[sortScenario].end < t2->scenarios[sortScenario].end
88 ? -1 : 1;
89 case EndDown:
90 return t1->scenarios[sortScenario].end ==
91 t2->scenarios[sortScenario].end ? 0 :
92 t1->scenarios[sortScenario].end > t2->scenarios[sortScenario].end
93 ? -1 : 1;
94 case StatusUp:
95 return t1->scenarios[sortScenario].status ==
96 t2->scenarios[sortScenario].status ? 0 :
97 t1->scenarios[sortScenario].status <
98 t2->scenarios[sortScenario].status ? -1 : 1;
99 case StatusDown:
100 return t1->scenarios[sortScenario].status ==
101 t2->scenarios[sortScenario].status ? 0 :
102 t1->scenarios[sortScenario].status >
103 t2->scenarios[sortScenario].status ? -1 : 1;
104 case CompletedUp:
105 {
106 /* Unfortunately the floating point arithmetic on x86 processors is
107 * slightly different from other processors. To get identical
108 * results on all CPUs we ignore some precision that we don't need
109 * anyhow. */
110 int cd1 = static_cast<int> (t1->getCompletionDegree(sortScenario) *
111 1000);
112 int cd2 = static_cast<int> (t2->getCompletionDegree(sortScenario) *
113 1000);
114 return cd1 == cd2 ? 0 : cd1 < cd2 ? -1 : 1;
115 }
116 case CompletedDown:
117 {
118 int cd1 = static_cast<int> (t1->getCompletionDegree(sortScenario) *
119 1000);
120 int cd2 = static_cast<int> (t2->getCompletionDegree(sortScenario) *
121 1000);
122 return cd1 == cd2 ? 0 : cd1 > cd2 ? -1 : 1;
123 }
124 case PrioUp:
125 if (t1->priority == t2->priority)
126 {
127 if (t1->scheduling == t2->scheduling)
128 return 0;
129 else if (t1->scheduling == Task::ASAP)
130 return -1;
131 }
132 else
133 return (t1->priority - t2->priority);
134 Q_FALLTHROUGH();
135 case PrioDown:
136 if (t1->priority == t2->priority)
137 {
138 if (t1->scheduling == t2->scheduling)
139 return 0;
140 else if (t1->scheduling == Task::ASAP)
141 return 1;
142 }
143 else
144 return (t2->priority - t1->priority);
145 Q_FALLTHROUGH();
146 case ResponsibleUp:
147 {
148 QString fn1;
149 t1->responsible->getFullName(fn1);
150 QString fn2;
151 t2->responsible->getFullName(fn2);
152 return fn1.compare(fn2);
153 }
154 case ResponsibleDown:
155 {
156 QString fn1;
157 t1->responsible->getFullName(fn1);
158 QString fn2;
159 t2->responsible->getFullName(fn2);
160 return -fn1.compare(fn2);
161 }
162 case CriticalnessUp:
163 return t1->scenarios[sortScenario].criticalness ==
164 t2->scenarios[sortScenario].criticalness ? 0 :
165 t1->scenarios[sortScenario].criticalness <
166 t2->scenarios[sortScenario].criticalness ? -1 : 1;
167 case CriticalnessDown:
168 return t1->scenarios[sortScenario].criticalness ==
169 t2->scenarios[sortScenario].criticalness ? 0 :
170 t1->scenarios[sortScenario].criticalness >
171 t2->scenarios[sortScenario].criticalness ? -1 : 1;
172 case PathCriticalnessUp:
173 return t1->scenarios[sortScenario].pathCriticalness ==
174 t2->scenarios[sortScenario].pathCriticalness ? 0 :
175 t1->scenarios[sortScenario].pathCriticalness <
176 t2->scenarios[sortScenario].pathCriticalness ? -1 : 1;
177 case PathCriticalnessDown:
178 return t1->scenarios[sortScenario].pathCriticalness ==
179 t2->scenarios[sortScenario].pathCriticalness ? 0 :
180 t1->scenarios[sortScenario].pathCriticalness >
181 t2->scenarios[sortScenario].pathCriticalness ? -1 : 1;
182 default:
183 return CoreAttributesList::compareItemsLevel(t1, t2, level);
184 }
185 }
186
187 Task* TaskListIterator::operator*()
188 {
189 return static_cast<Task*>(CoreAttributesListIterator::operator*());
190 }
191
192 } // namespace TJ