GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 76.1% 86 / 0 / 113
Functions: 90.5% 19 / 0 / 21
Branches: 65.3% 64 / 0 / 98

src/utilities/idf/ObjectOrderBase.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 "ObjectOrderBase.hpp"
7 #include "../math/Permutation.hpp"
8
9 namespace openstudio {
10
11 // CONSTRUCTORS
12
13 2 ObjectOrderBase::ObjectOrderBase() : m_orderByIddEnum(true) {}
14
15 18198 ObjectOrderBase::ObjectOrderBase(bool directOrder) : m_orderByIddEnum(!directOrder) {}
16
17 2 ObjectOrderBase::ObjectOrderBase(const IddObjectTypeVector& iddOrder) : m_orderByIddEnum(false), m_iddOrder(iddOrder) {}
18
19 // GETTERS AND SETTERS
20
21 6 bool ObjectOrderBase::orderByIddEnum() const {
22 6 return m_orderByIddEnum;
23 }
24
25 2 void ObjectOrderBase::setOrderByIddEnum() {
26 2 m_iddOrder = boost::none;
27 2 m_orderByIddEnum = true;
28 2 }
29
30 11239 boost::optional<IddObjectTypeVector> ObjectOrderBase::iddOrder() const {
31 11239 return m_iddOrder;
32 }
33
34 2 void ObjectOrderBase::setIddOrder(const IddObjectTypeVector& order) {
35 2 m_iddOrder = order;
36 2 m_orderByIddEnum = false;
37 2 }
38
39 1 bool ObjectOrderBase::push_back(IddObjectType type) {
40
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
1 if (!m_iddOrder) {
41 ✗ return false;
42 }
43 1 m_iddOrder->push_back(type);
44 1 return true;
45 }
46
47 4 bool ObjectOrderBase::insert(IddObjectType type, IddObjectType insertBeforeType) {
48
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
4 if (!m_iddOrder) {
49 ✗ return false;
50 }
51
1/1
✓ Branch 1 taken 4 times.
4 auto it = getIterator(insertBeforeType);
52
2/2
✓ Branch 1 taken 4 times.
✓ Branch 5 taken 4 times.
4 m_iddOrder->insert(it, type);
53 4 return true;
54 }
55
56 5 bool ObjectOrderBase::insert(IddObjectType type, unsigned index) {
57
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
5 if (!m_iddOrder) {
58 ✗ return false;
59 }
60
2/2
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2 times.
5 if (index < m_iddOrder->size()) {
61
1/1
✓ Branch 1 taken 3 times.
3 auto it = m_iddOrder->begin();
62
2/2
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 3 times.
68 for (unsigned i = 0; i < index; ++i, ++it) {
63 ;
64 }
65
2/2
✓ Branch 1 taken 3 times.
✓ Branch 5 taken 3 times.
3 m_iddOrder->insert(it, type);
66 } else {
67 2 m_iddOrder->push_back(type);
68 }
69 5 return true;
70 }
71
72 3 bool ObjectOrderBase::move(IddObjectType type, IddObjectType insertBeforeType) {
73
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
3 if (!m_iddOrder) {
74 ✗ return false;
75 }
76 // find type in order
77
1/1
✓ Branch 1 taken 3 times.
3 auto it = getIterator(type);
78
3/3
✓ Branch 1 taken 3 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 2 times.
3 if (it == m_iddOrder->end()) {
79 1 return false;
80 }
81 // handle degenerate case
82
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
2 if (type == insertBeforeType) {
83 ✗ return true;
84 }
85 // erase type
86
2/2
✓ Branch 1 taken 2 times.
✓ Branch 5 taken 2 times.
2 m_iddOrder->erase(it);
87 // reinsert at given location
88
1/1
✓ Branch 1 taken 2 times.
2 return insert(type, insertBeforeType);
89 }
90
91 4 bool ObjectOrderBase::move(IddObjectType type, unsigned index) {
92
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
4 if (!m_iddOrder) {
93 ✗ return false;
94 }
95 // find type in order
96
1/1
✓ Branch 1 taken 4 times.
4 auto it = getIterator(type);
97
3/3
✓ Branch 1 taken 4 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 3 times.
4 if (it == m_iddOrder->end()) {
98 1 return false;
99 }
100 // handle degenerate case
101
2/3
✓ Branch 1 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
3 if ((it - m_iddOrder->begin()) == static_cast<int>(index)) {
102 ✗ return true;
103 }
104 // erase type
105
2/2
✓ Branch 1 taken 3 times.
✓ Branch 5 taken 3 times.
3 m_iddOrder->erase(it);
106 // reinsert at given index
107
1/1
✓ Branch 1 taken 3 times.
3 return insert(type, index);
108 }
109
110 1 bool ObjectOrderBase::swap(IddObjectType type1, IddObjectType type2) {
111
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
1 if (!m_iddOrder) {
112 ✗ return false;
113 }
114 // ETH@20100408 \todo Would std::swap work? Better?
115
1/1
✓ Branch 1 taken 1 time.
1 auto it1 = getIterator(type1);
116
1/1
✓ Branch 1 taken 1 time.
1 auto it2 = getIterator(type2);
117
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_iddOrder->end()) || (it2 == m_iddOrder->end())) {
118 ✗ return false;
119 }
120
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
1 if (it1 == it2) {
121 ✗ return true;
122 }
123 1 *it1 = type2;
124 1 *it2 = type1;
125 1 return true;
126 }
127
128 2 bool ObjectOrderBase::erase(IddObjectType type) {
129
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
2 if (!m_iddOrder) {
130 ✗ return false;
131 }
132
1/1
✓ Branch 1 taken 2 times.
2 auto it = getIterator(type);
133
3/3
✓ Branch 1 taken 2 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 1 time.
2 if (it == m_iddOrder->end()) {
134 1 return false;
135 }
136
2/2
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
1 m_iddOrder->erase(it);
137 1 return true;
138 }
139
140 30962 void ObjectOrderBase::setDirectOrder() {
141 30962 m_orderByIddEnum = false;
142 30962 m_iddOrder = boost::none;
143 30962 }
144
145 // SORTING
146
147 9265 bool ObjectOrderBase::less(IddObjectType left, IddObjectType right) const {
148
2/2
✓ Branch 0 taken 3110 times.
✓ Branch 1 taken 6155 times.
9265 if (m_orderByIddEnum) {
149 3110 return (left < right);
150 } else {
151
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6155 times.
6155 OS_ASSERT(m_iddOrder);
152
2/2
✓ Branch 1 taken 6155 times.
✓ Branch 4 taken 6155 times.
6155 return (getIterator(left) < getIterator(right));
153 }
154 }
155
156 ✗ bool ObjectOrderBase::less(boost::optional<IddObjectType> left, boost::optional<IddObjectType> right) const {
157 ✗ if (left && right) {
158 ✗ return less(*left, *right);
159 }
160 ✗ if (left) {
161 ✗ return true;
162 }
163 ✗ if (right) {
164 ✗ return false;
165 }
166 ✗ return true;
167 }
168
169 // STATE CHECKING
170
171 ✗ bool ObjectOrderBase::inOrder(const IddObjectType& type) const {
172 ✗ if (m_orderByIddEnum) {
173 ✗ return true;
174 }
175 ✗ if (m_iddOrder) {
176 ✗ auto it = getIterator(type);
177 ✗ if (it != m_iddOrder->end()) {
178 ✗ return true;
179 }
180 }
181 ✗ return false;
182 }
183
184 21 OptionalUnsigned ObjectOrderBase::indexInOrder(const IddObjectType& type) const {
185
2/2
✓ Branch 0 taken 1 time.
✓ Branch 1 taken 20 times.
21 if (m_orderByIddEnum) {
186
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 return static_cast<unsigned>(type.value());
187 }
188
2/2
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 1 time.
40 if (m_iddOrder) {
189
1/1
✓ Branch 1 taken 19 times.
19 auto it = getIterator(type);
190
2/2
✓ Branch 1 taken 19 times.
✓ Branch 6 taken 19 times.
19 return (unsigned)(it - m_iddOrder->begin());
191 }
192 1 return boost::none;
193 }
194
195 // PRIVATE
196
197 // assumes that m_iddOrder == true
198 15 IddObjectTypeVector::iterator ObjectOrderBase::getIterator(const IddObjectType& type) {
199
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
15 OS_ASSERT(m_iddOrder);
200 15 return std::find(m_iddOrder->begin(), m_iddOrder->end(), type);
201 }
202
203 12329 IddObjectTypeVector::const_iterator ObjectOrderBase::getIterator(const IddObjectType& type) const {
204
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12329 times.
12329 OS_ASSERT(m_iddOrder);
205 12329 return std::find(m_iddOrder->begin(), m_iddOrder->end(), type);
206 }
207
208 } // namespace openstudio
209