GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 55.0% 126 / 0 / 229
Functions: 65.6% 40 / 0 / 61
Branches: 40.5% 68 / 0 / 168

src/utilities/idf/WorkspaceObjectOrder.cpp
Line Branch Exec Source
1 /***********************************************************************************************************************
2 * OpenStudio(R), Copyright (c) Alliance for Energy Innovation, LLC.
3 * See also https://openstudio.net/license
4 ***********************************************************************************************************************/
5
6 #include "WorkspaceObjectOrder.hpp"
7
8 #include "../idd/IddObject.hpp"
9
10 #include "../math/Permutation.hpp"
11
12 #include <iterator>
13
14 namespace openstudio {
15
16 namespace detail {
17 // CONSTRUCTORS
18
19 ✗ WorkspaceObjectOrder_Impl::WorkspaceObjectOrder_Impl(const ObjectGetter& objectGetter) : ObjectOrderBase(), m_objectGetter(objectGetter) {}
20
21 18197 WorkspaceObjectOrder_Impl::WorkspaceObjectOrder_Impl(const std::vector<Handle>& directOrder, const ObjectGetter& objectGetter)
22
2/2
✓ Branch 2 taken 18197 times.
✓ Branch 5 taken 18197 times.
18197 : ObjectOrderBase(true), m_objectGetter(objectGetter), m_directOrder(directOrder) {}
23
24 ✗ WorkspaceObjectOrder_Impl::WorkspaceObjectOrder_Impl(const std::vector<IddObjectType>& iddOrder, const ObjectGetter& objectGetter)
25 ✗ : ObjectOrderBase(iddOrder), m_objectGetter(objectGetter) {}
26
27 // GETTERS AND SETTERS
28
29 429693 bool WorkspaceObjectOrder_Impl::isDirectOrder() const {
30 429693 return m_directOrder.has_value();
31 }
32
33 23659 boost::optional<std::vector<Handle>> WorkspaceObjectOrder_Impl::directOrder() const {
34 23659 return m_directOrder;
35 }
36
37 30961 void WorkspaceObjectOrder_Impl::setDirectOrder(const std::vector<Handle>& order) {
38 /// \todo Elements in order should be unique? Algorithms will still work if not true, but
39 /// may get unexpected results.
40 30961 ObjectOrderBase::setDirectOrder();
41 30961 m_directOrder = order;
42 30961 }
43
44 414022 bool WorkspaceObjectOrder_Impl::push_back(const Handle& handle) {
45
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 414022 times.
414022 if (!m_directOrder) {
46 ✗ return false;
47 }
48 414022 m_directOrder->push_back(handle);
49 414022 return true;
50 }
51
52 1 bool WorkspaceObjectOrder_Impl::insert(const Handle& handle, const Handle& insertBeforeHandle) {
53
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
1 if (!m_directOrder) {
54 ✗ return false;
55 }
56
1/1
✓ Branch 1 taken 1 time.
1 auto it = getIterator(insertBeforeHandle);
57
2/2
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
1 m_directOrder->insert(it, handle);
58 1 return true;
59 }
60
61 91 bool WorkspaceObjectOrder_Impl::insert(const Handle& handle, unsigned index) {
62
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 91 times.
91 if (!m_directOrder) {
63 ✗ return false;
64 }
65
1/2
✓ Branch 2 taken 91 times.
✗ Branch 3 not taken.
91 if (index < m_directOrder->size()) {
66
1/1
✓ Branch 1 taken 91 times.
91 auto it = std::next(m_directOrder->begin(), index);
67
2/2
✓ Branch 1 taken 91 times.
✓ Branch 5 taken 91 times.
91 m_directOrder->insert(it, handle);
68 91 return true;
69 } else {
70 ✗ m_directOrder->push_back(handle);
71 ✗ return true;
72 }
73 }
74
75 ✗ bool WorkspaceObjectOrder_Impl::move(const Handle& handle, const Handle& insertBeforeHandle) {
76 ✗ if (!m_directOrder) {
77 ✗ return false;
78 }
79 // find type in order
80 ✗ auto it = getIterator(handle);
81 ✗ if (it == m_directOrder->end()) {
82 ✗ return false;
83 }
84 // handle degenerate case
85 ✗ if (handle == insertBeforeHandle) {
86 ✗ return true;
87 }
88 // erase handle
89 ✗ m_directOrder->erase(it);
90 // reinsert at given location
91 ✗ return insert(handle, insertBeforeHandle);
92 }
93
94 91 bool WorkspaceObjectOrder_Impl::move(const Handle& handle, unsigned index) {
95
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 91 times.
91 if (!m_directOrder) {
96 ✗ return false;
97 }
98 // find type in order
99
1/1
✓ Branch 1 taken 91 times.
91 auto it = getIterator(handle);
100
2/3
✓ Branch 1 taken 91 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 91 times.
91 if (it == m_directOrder->end()) {
101 ✗ return false;
102 }
103 // handle degenerate case
104
2/3
✓ Branch 1 taken 91 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 91 times.
91 if ((it - m_directOrder->begin()) == static_cast<int>(index)) {
105 ✗ return true;
106 }
107 // erase handle
108
2/2
✓ Branch 1 taken 91 times.
✓ Branch 5 taken 91 times.
91 m_directOrder->erase(it);
109 // reinsert at given location
110
1/1
✓ Branch 1 taken 91 times.
91 return insert(handle, index);
111 }
112
113 1 bool WorkspaceObjectOrder_Impl::swap(const Handle& handle1, const Handle& handle2) {
114
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
1 if (!m_directOrder) {
115 ✗ return false;
116 }
117
1/1
✓ Branch 1 taken 1 time.
1 auto it1 = getIterator(handle1);
118
1/1
✓ Branch 1 taken 1 time.
1 auto it2 = getIterator(handle2);
119
5/8
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 8 taken 1 time.
✗ Branch 12 not taken.
✓ Branch 13 taken 1 time.
✗ Branch 14 not taken.
✓ Branch 15 taken 1 time.
1 if ((it1 == m_directOrder->end()) || (it2 == m_directOrder->end())) {
120 ✗ return false;
121 }
122
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
1 if (it1 == it2) {
123 ✗ return true;
124 }
125 1 *it1 = handle2;
126 1 *it2 = handle1;
127 1 return true;
128 }
129
130 9931 bool WorkspaceObjectOrder_Impl::erase(const Handle& handle) {
131
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9931 times.
9931 if (!m_directOrder) {
132 ✗ return false;
133 }
134
1/1
✓ Branch 1 taken 9931 times.
9931 auto it = getIterator(handle);
135
2/3
✓ Branch 1 taken 9931 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9931 times.
9931 if (it == m_directOrder->end()) {
136 ✗ return false;
137 }
138
2/2
✓ Branch 1 taken 9931 times.
✓ Branch 5 taken 9931 times.
9931 m_directOrder->erase(it);
139 9931 return true;
140 }
141
142 1 void WorkspaceObjectOrder_Impl::setOrderByIddEnum() {
143 1 ObjectOrderBase::setOrderByIddEnum();
144 1 m_directOrder = boost::none;
145 1 }
146
147 1 void WorkspaceObjectOrder_Impl::setIddOrder(const std::vector<IddObjectType>& order) {
148 1 ObjectOrderBase::setIddOrder(order);
149 1 m_directOrder = boost::none;
150 1 }
151
152 // SORTING
153
154 /** Predicate for external sorters (for instance, std::set). */
155 9762 bool WorkspaceObjectOrder_Impl::less(const Handle& left, const Handle& right) const {
156
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9762 times.
9762 if (!m_directOrder) {
157 ✗ return ObjectOrderBase::less(getIddObjectType(left), getIddObjectType(right));
158 } else {
159
2/2
✓ Branch 1 taken 9762 times.
✓ Branch 4 taken 9762 times.
9762 return (getIterator(left) < getIterator(right));
160 }
161 }
162
163 /** Predicate for external sorters (for instance, std::set). */
164 1857512 bool WorkspaceObjectOrder_Impl::less(const WorkspaceObject& left, const WorkspaceObject& right) const {
165
2/2
✓ Branch 1 taken 9259 times.
✓ Branch 2 taken 1848253 times.
1857512 if (!m_directOrder) {
166
5/5
✓ Branch 1 taken 9259 times.
✓ Branch 4 taken 9259 times.
✓ Branch 7 taken 9259 times.
✓ Branch 10 taken 9259 times.
✓ Branch 13 taken 9259 times.
9259 return ObjectOrderBase::less(left.iddObject().type(), right.iddObject().type());
167 } else {
168
2/2
✓ Branch 1 taken 1848253 times.
✓ Branch 4 taken 1848253 times.
1848253 return (getIterator(left) < getIterator(right));
169 }
170 }
171
172 ✗ bool WorkspaceObjectOrder_Impl::less(IddObjectType left, IddObjectType right) const {
173 ✗ if (!m_directOrder) {
174 ✗ return ObjectOrderBase::less(left, right);
175 } else {
176 ✗ return (getIterator(left) < getIterator(right));
177 }
178 }
179
180 3 std::vector<Handle> WorkspaceObjectOrder_Impl::sort(const std::vector<Handle>& handles) const {
181 3 HandleVector result(handles);
182
1/1
✓ Branch 4 taken 3 times.
9765 std::sort(result.begin(), result.end(), [this](const auto& lhs, const auto& rhs) { return less(lhs, rhs); });
183 3 return result;
184 ✗ }
185
186 820 std::vector<WorkspaceObject> WorkspaceObjectOrder_Impl::sort(const std::vector<WorkspaceObject>& objects) const {
187 820 WorkspaceObjectVector result(objects);
188
1/1
✓ Branch 4 taken 820 times.
1858332 std::sort(result.begin(), result.end(), [this](const auto& lhs, const auto& rhs) { return less(lhs, rhs); });
189 820 return result;
190 ✗ }
191
192 /// returns empty vector if not all handles can be converted to objects
193 ✗ std::vector<WorkspaceObject> WorkspaceObjectOrder_Impl::sortedObjects(const std::vector<Handle>& handles) const {
194 ✗ if (isDirectOrder()) {
195 // easier to sort handles
196 ✗ HandleVector sorted = sort(handles);
197 ✗ return getObjects(sorted);
198 ✗ } else {
199 // easier to sort objects, and have to get them anyway
200 ✗ WorkspaceObjectVector objects = getObjects(handles);
201 ✗ return sort(objects);
202 ✗ }
203 }
204 /// returns empty vector if not all objects can be converted to handles
205 ✗ std::vector<Handle> WorkspaceObjectOrder_Impl::sortedHandles(const std::vector<WorkspaceObject>& objects) const {
206 ✗ if (isDirectOrder()) {
207 // easier to sort handles, get first and sort
208 ✗ HandleVector handles = getHandles<WorkspaceObject>(objects);
209 ✗ return sort(handles);
210 ✗ } else {
211 // easier to sort objects, sort, then get handles
212 ✗ WorkspaceObjectVector sorted = sort(objects);
213 ✗ return getHandles<WorkspaceObject>(sorted);
214 ✗ }
215 }
216
217 // STATE CHECKING
218
219 /** Returns whether order of handle is directly specified. */
220 1 bool WorkspaceObjectOrder_Impl::inOrder(const Handle& handle) const {
221
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
2 if (m_directOrder) {
222
1/1
✓ Branch 1 taken 1 time.
1 auto loc = getIterator(handle);
223
2/3
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
✗ Branch 6 not taken.
1 if (loc != m_directOrder->end()) {
224 1 return true;
225 }
226 }
227 ✗ return false;
228 }
229
230 /** Returns index of handle in order, if its order is directly specified. */
231 13363 boost::optional<unsigned> WorkspaceObjectOrder_Impl::indexInOrder(const Handle& handle) const {
232
2/2
✓ Branch 1 taken 13362 times.
✓ Branch 2 taken 1 time.
26726 if (m_directOrder) {
233
1/1
✓ Branch 1 taken 13362 times.
13362 auto loc = getIterator(handle);
234
2/3
✓ Branch 1 taken 13362 times.
✓ Branch 5 taken 13362 times.
✗ Branch 6 not taken.
13362 if (loc != m_directOrder->end()) {
235
2/2
✓ Branch 1 taken 13362 times.
✓ Branch 6 taken 13362 times.
13362 return (unsigned)(loc - m_directOrder->begin());
236 }
237 }
238 1 return boost::none;
239 }
240
241 // PROTECTED
242
243 ✗ void WorkspaceObjectOrder_Impl::setObjectGetter(const ObjectGetter& getter) {
244 ✗ m_objectGetter = getter;
245 ✗ }
246
247 // PRIVATE
248
249 // only call when m_directOrder == true
250 10025 std::vector<Handle>::iterator WorkspaceObjectOrder_Impl::getIterator(const Handle& handle) {
251
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10025 times.
10025 OS_ASSERT(m_directOrder);
252 10025 return std::find(m_directOrder->begin(), m_directOrder->end(), handle);
253 }
254
255 ✗ std::vector<Handle>::iterator WorkspaceObjectOrder_Impl::getIterator(IddObjectType type) {
256 ✗ OS_ASSERT(m_directOrder);
257 ✗ for (auto it = m_directOrder->begin(), itEnd = m_directOrder->end(); it != itEnd; ++it) {
258 ✗ if (getIddObjectType(*it) == type) {
259 ✗ return it;
260 }
261 }
262 ✗ return m_directOrder->end();
263 }
264
265 ✗ std::vector<Handle>::iterator WorkspaceObjectOrder_Impl::getIterator(const WorkspaceObject& object) {
266 ✗ OS_ASSERT(m_directOrder);
267 ✗ return std::find(m_directOrder->begin(), m_directOrder->end(), object.handle());
268 }
269
270 32887 std::vector<Handle>::const_iterator WorkspaceObjectOrder_Impl::getIterator(const Handle& handle) const {
271
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32887 times.
32887 OS_ASSERT(m_directOrder);
272 32887 return std::find(m_directOrder->begin(), m_directOrder->end(), handle);
273 }
274
275 ✗ std::vector<Handle>::const_iterator WorkspaceObjectOrder_Impl::getIterator(IddObjectType type) const {
276 ✗ OS_ASSERT(m_directOrder);
277 ✗ for (auto it = m_directOrder->begin(), itEnd = m_directOrder->end(); it != itEnd; ++it) {
278 ✗ if (getIddObjectType(*it) == type) {
279 ✗ return it;
280 }
281 }
282 ✗ return m_directOrder->end();
283 }
284
285 3696506 std::vector<Handle>::const_iterator WorkspaceObjectOrder_Impl::getIterator(const WorkspaceObject& object) const {
286
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3696506 times.
3696506 OS_ASSERT(m_directOrder);
287
4/4
✓ Branch 1 taken 3696506 times.
✓ Branch 4 taken 3696506 times.
✓ Branch 8 taken 3696506 times.
✓ Branch 12 taken 3696506 times.
3696506 return std::find(m_directOrder->begin(), m_directOrder->end(), object.handle());
288 }
289
290 ✗ boost::optional<IddObjectType> WorkspaceObjectOrder_Impl::getIddObjectType(const Handle& handle) const {
291 ✗ OS_ASSERT(m_objectGetter);
292 ✗ OptionalWorkspaceObject object = m_objectGetter(handle);
293 ✗ if (object) {
294 ✗ return object->iddObject().type();
295 } else {
296 ✗ return boost::none;
297 }
298 ✗ }
299
300 ✗ std::vector<WorkspaceObject> WorkspaceObjectOrder_Impl::getObjects(const std::vector<Handle>& handles) const {
301 ✗ WorkspaceObjectVector objects;
302 // loop through handles and try to find objects
303 ✗ for (const Handle& handle : handles) {
304 ✗ OS_ASSERT(m_objectGetter);
305 ✗ OptionalWorkspaceObject object = m_objectGetter(handle);
306 ✗ if (object) {
307 ✗ objects.push_back(*object);
308 }
309 ✗ }
310 ✗ return objects;
311 ✗ }
312
313 } // namespace detail
314
315 // GETTERS AND SETTERS
316
317 ✗ bool WorkspaceObjectOrder::orderByIddEnum() const {
318 ✗ return m_impl->orderByIddEnum();
319 }
320
321 1 void WorkspaceObjectOrder::setOrderByIddEnum() {
322 1 m_impl->setOrderByIddEnum();
323 1 }
324
325 11223 boost::optional<std::vector<IddObjectType>> WorkspaceObjectOrder::iddOrder() const {
326 11223 return m_impl->iddOrder();
327 }
328
329 1 void WorkspaceObjectOrder::setIddOrder(const std::vector<IddObjectType>& order) {
330 1 m_impl->setIddOrder(order);
331 1 }
332
333 ✗ bool WorkspaceObjectOrder::push_back(IddObjectType type) {
334 ✗ return m_impl->ObjectOrderBase::push_back(type);
335 }
336
337 ✗ bool WorkspaceObjectOrder::insert(IddObjectType type, IddObjectType insertBeforeType) {
338 ✗ return m_impl->ObjectOrderBase::insert(type, insertBeforeType);
339 }
340
341 ✗ bool WorkspaceObjectOrder::insert(IddObjectType type, unsigned index) {
342 ✗ return m_impl->ObjectOrderBase::insert(type, index);
343 }
344
345 ✗ bool WorkspaceObjectOrder::move(IddObjectType type, IddObjectType insertBeforeType) {
346 ✗ return m_impl->ObjectOrderBase::move(type, insertBeforeType);
347 }
348
349 1 bool WorkspaceObjectOrder::move(IddObjectType type, unsigned index) {
350 1 return m_impl->ObjectOrderBase::move(type, index);
351 }
352
353 ✗ bool WorkspaceObjectOrder::swap(IddObjectType type1, IddObjectType type2) {
354 ✗ return m_impl->ObjectOrderBase::swap(type1, type2);
355 }
356
357 ✗ bool WorkspaceObjectOrder::erase(IddObjectType type) {
358 ✗ return m_impl->ObjectOrderBase::erase(type);
359 }
360
361 429693 bool WorkspaceObjectOrder::isDirectOrder() const {
362 429693 return m_impl->isDirectOrder();
363 }
364
365 23659 boost::optional<std::vector<Handle>> WorkspaceObjectOrder::directOrder() const {
366 23659 return m_impl->directOrder();
367 }
368
369 30961 void WorkspaceObjectOrder::setDirectOrder(const std::vector<Handle>& order) {
370 30961 m_impl->setDirectOrder(order);
371 30961 }
372
373 414022 bool WorkspaceObjectOrder::push_back(const Handle& handle) {
374 414022 return m_impl->push_back(handle);
375 }
376
377 1 bool WorkspaceObjectOrder::insert(const Handle& handle, const Handle& insertBeforeHandle) {
378 1 return m_impl->insert(handle, insertBeforeHandle);
379 }
380
381 ✗ bool WorkspaceObjectOrder::insert(const Handle& handle, unsigned index) {
382 ✗ return m_impl->insert(handle, index);
383 }
384
385 ✗ bool WorkspaceObjectOrder::move(const Handle& handle, const Handle& insertBeforeHandle) {
386 ✗ return m_impl->move(handle, insertBeforeHandle);
387 }
388
389 91 bool WorkspaceObjectOrder::move(const Handle& handle, unsigned index) {
390 91 return m_impl->move(handle, index);
391 }
392
393 1 bool WorkspaceObjectOrder::swap(const Handle& handle1, const Handle& handle2) {
394 1 return m_impl->swap(handle1, handle2);
395 }
396
397 9931 bool WorkspaceObjectOrder::erase(const Handle& handle) {
398 9931 return m_impl->erase(handle);
399 }
400
401 // SORTING
402
403 3 std::vector<Handle> WorkspaceObjectOrder::sort(const std::vector<Handle>& handles) const {
404 3 return m_impl->sort(handles);
405 }
406
407 820 std::vector<WorkspaceObject> WorkspaceObjectOrder::sort(const std::vector<WorkspaceObject>& objects) const {
408 820 return m_impl->sort(objects);
409 }
410
411 // STATE CHECKING
412
413 1 bool WorkspaceObjectOrder::inOrder(const Handle& handle) const {
414 1 return m_impl->inOrder(handle);
415 }
416
417 13363 boost::optional<unsigned> WorkspaceObjectOrder::indexInOrder(const Handle& handle) const {
418 13363 return m_impl->indexInOrder(handle);
419 }
420
421 // PROTECTED
422
423 // CONSTRUCTORS
424
425 18197 WorkspaceObjectOrder::WorkspaceObjectOrder(const std::shared_ptr<detail::WorkspaceObjectOrder_Impl>& impl) : m_impl(impl) {}
426
427 } // namespace openstudio
428