GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 0.0% 0 / 0 / 140
Functions: 0.0% 0 / 0 / 33
Branches: 0.0% 0 / 0 / 168

src/utilities/sql/SqlFileTimeSeriesQuery.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 <iomanip>
7 #include "SqlFileTimeSeriesQuery.hpp"
8
9 #include "../core/Assert.hpp"
10 #include "../core/Optional.hpp"
11 #include "../core/Containers.hpp"
12
13 namespace openstudio {
14
15 // ENVIRONMENT IDENTIFIER
16
17 ✗ EnvironmentIdentifier::EnvironmentIdentifier(const EnvironmentType& type) : m_type(type) {}
18
19 ✗ EnvironmentIdentifier::EnvironmentIdentifier(const std::string& name) : m_name(name) {}
20
21 ✗ OptionalEnvironmentType EnvironmentIdentifier::type() const {
22 ✗ return m_type;
23 }
24
25 ✗ OptionalString EnvironmentIdentifier::name() const {
26 ✗ return m_name;
27 }
28
29 // TIMESERIES IDENTIFIER
30
31 ✗ TimeSeriesIdentifier::TimeSeriesIdentifier(const std::string& name) : m_name(name) {}
32
33 ✗ TimeSeriesIdentifier::TimeSeriesIdentifier(const boost::regex& re) : m_re(re) {}
34
35 ✗ OptionalString TimeSeriesIdentifier::name() const {
36 ✗ return m_name;
37 }
38
39 ✗ boost::optional<boost::regex> TimeSeriesIdentifier::regex() const {
40 ✗ return m_re;
41 }
42
43 // KEYVALUE IDENTIFIER
44
45 ✗ KeyValueIdentifier::KeyValueIdentifier(const std::string& name) : m_names(1, name) {}
46
47 ✗ KeyValueIdentifier::KeyValueIdentifier(const std::vector<std::string>& names) : m_names(names) {
48 ✗ if (m_names.empty()) {
49 ✗ LOG_AND_THROW("KeyValueIdentifier cannot be constructed from an empty string vector. " << "Please use an OptionalKeyValueIdentifier instead.");
50 }
51 ✗ }
52
53 ✗ KeyValueIdentifier::KeyValueIdentifier(const boost::regex& re) : m_re(re) {}
54
55 ✗ StringVector KeyValueIdentifier::names() const {
56 ✗ return m_names;
57 }
58
59 ✗ boost::optional<boost::regex> KeyValueIdentifier::regex() const {
60 ✗ if (!m_names.empty()) {
61 ✗ return boost::none;
62 }
63 ✗ return m_re;
64 }
65
66 // SQLFILE TIMESERIES QUERY
67
68 ✗ SqlFileTimeSeriesQuery::SqlFileTimeSeriesQuery(const boost::optional<EnvironmentIdentifier>& oEnvId, const boost::optional<ReportingFrequency>& oRF,
69 ✗ const boost::optional<TimeSeriesIdentifier>& oTsId, const boost::optional<KeyValueIdentifier>& oKvId)
70 ✗ : m_vetted(false), m_environment(oEnvId), m_reportingFrequency(oRF), m_timeSeries(oTsId), m_keyValues(oKvId) {}
71
72 ✗ SqlFileTimeSeriesQuery::SqlFileTimeSeriesQuery(const EnvironmentIdentifier& envId) : m_vetted(false), m_environment(envId) {}
73
74 ✗ SqlFileTimeSeriesQuery::SqlFileTimeSeriesQuery(const std::string& environmentPeriod, const ReportingFrequency& reportingFrequency,
75 ✗ const std::string& timeSeriesName, const std::string& keyValue)
76 ✗ : m_vetted(false),
77 ✗ m_environment(EnvironmentIdentifier(environmentPeriod)),
78 ✗ m_reportingFrequency(reportingFrequency),
79 ✗ m_timeSeries(TimeSeriesIdentifier(timeSeriesName)),
80 ✗ m_keyValues(KeyValueIdentifier(keyValue)) {}
81
82 // GETTERS
83
84 ✗ OptionalEnvironmentIdentifier SqlFileTimeSeriesQuery::environment() const {
85 ✗ return m_environment;
86 }
87
88 ✗ OptionalReportingFrequency SqlFileTimeSeriesQuery::reportingFrequency() const {
89 ✗ return m_reportingFrequency;
90 }
91
92 ✗ OptionalTimeSeriesIdentifier SqlFileTimeSeriesQuery::timeSeries() const {
93 ✗ return m_timeSeries;
94 }
95
96 ✗ OptionalKeyValueIdentifier SqlFileTimeSeriesQuery::keyValues() const {
97 ✗ return m_keyValues;
98 }
99
100 ✗ bool SqlFileTimeSeriesQuery::vetted() const {
101 ✗ return m_vetted;
102 }
103
104 // SETTERS
105
106 ✗ void SqlFileTimeSeriesQuery::setEnvironment(const EnvironmentIdentifier& envId) {
107 ✗ m_environment = envId;
108 ✗ m_vetted = false;
109 ✗ }
110
111 ✗ void SqlFileTimeSeriesQuery::setReportingFrequency(const ReportingFrequency& rf) {
112 ✗ m_reportingFrequency = rf;
113 ✗ m_vetted = false;
114 ✗ }
115
116 ✗ void SqlFileTimeSeriesQuery::setTimeSeries(const TimeSeriesIdentifier& tsId) {
117 ✗ m_timeSeries = tsId;
118 ✗ m_vetted = false;
119 ✗ }
120
121 ✗ void SqlFileTimeSeriesQuery::setKeyValues(const KeyValueIdentifier& kvId) {
122 ✗ m_keyValues = kvId;
123 ✗ m_vetted = false;
124 ✗ }
125
126 ✗ void SqlFileTimeSeriesQuery::clearEnvironment() {
127 ✗ m_environment = boost::none;
128 ✗ m_vetted = false;
129 ✗ }
130
131 ✗ void SqlFileTimeSeriesQuery::clearReportingFrequency() {
132 ✗ m_reportingFrequency = boost::none;
133 ✗ m_vetted = false;
134 ✗ }
135
136 ✗ void SqlFileTimeSeriesQuery::clearTimeSeries() {
137 ✗ m_timeSeries = boost::none;
138 ✗ m_vetted = false;
139 ✗ }
140
141 ✗ void SqlFileTimeSeriesQuery::clearKeyValues() {
142 ✗ m_keyValues = boost::none;
143 ✗ m_vetted = false;
144 ✗ }
145
146 // NON-MEMBER FUNCTIONS
147
148 ✗ std::ostream& operator<<(std::ostream& os, const SqlFileTimeSeriesQuery& query) {
149 ✗ os << '\n';
150 ✗ if (query.environment()) {
151 ✗ EnvironmentIdentifier envId = query.environment().get();
152 ✗ if (envId.type()) {
153 ✗ os << "Environment Period: Of type '" << envId.type().get().valueDescription() << "'" << '\n';
154 } else {
155 ✗ os << "Environment Period: " << envId.name().get() << '\n';
156 }
157 ✗ } else {
158 ✗ os << "Environment Period: Not Specified" << '\n';
159 }
160 ✗ if (query.reportingFrequency()) {
161 ✗ os << "Reporting Frequency: " << query.reportingFrequency().get().valueDescription() << '\n';
162 } else {
163 ✗ os << "Reporting Frequency: Not Specified" << '\n';
164 }
165 ✗ if (query.timeSeries()) {
166 ✗ TimeSeriesIdentifier tsId = query.timeSeries().get();
167 ✗ if (tsId.regex()) {
168 ✗ os << "Time Series: Match regex '" << tsId.regex().get() << "'" << '\n';
169 } else {
170 ✗ os << "Time Series: " << tsId.name().get() << '\n';
171 }
172 ✗ } else {
173 ✗ os << "Time Series: Not Specified" << '\n';
174 }
175 ✗ StringVector names;
176 ✗ if (query.keyValues()) {
177 ✗ KeyValueIdentifier kvId = query.keyValues().get();
178 ✗ if (kvId.regex()) {
179 ✗ os << "Key Values: Match regex '" << kvId.regex().get() << "'" << '\n';
180 } else {
181 ✗ names = kvId.names();
182 ✗ if (names.size() == 1) {
183 ✗ os << "Key Value: " << names[0] << '\n';
184 } else {
185 ✗ OS_ASSERT(names.size() > 1);
186 ✗ os << "Key Values: " << names[0] << '\n';
187 ✗ for (unsigned i = 1, n = names.size(); i < n; ++i) {
188 ✗ os << std::setw(21) << " " << names[i] << '\n';
189 }
190 }
191 }
192 ✗ } else {
193 ✗ os << "Key Value: Not Specified" << '\n';
194 }
195 ✗ os << '\n';
196
197 ✗ return os;
198 ✗ }
199
200 ✗ StringSet environmentPeriods(const SqlFileTimeSeriesQueryVector& queries) {
201 ✗ StringSet result;
202 ✗ for (const SqlFileTimeSeriesQuery& q : queries) {
203 ✗ if (!q.vetted()) {
204 ✗ return {};
205 }
206 ✗ OS_ASSERT(q.environment().get().name());
207 ✗ result.insert(*(q.environment().get().name()));
208 }
209 ✗ return result;
210 ✗ }
211
212 ✗ ReportingFrequencySet reportingFrequencies(const SqlFileTimeSeriesQueryVector& queries) {
213 ✗ ReportingFrequencySet result;
214 ✗ for (const SqlFileTimeSeriesQuery& q : queries) {
215 ✗ if (!q.vetted()) {
216 ✗ return {};
217 }
218 ✗ OS_ASSERT(q.reportingFrequency());
219 ✗ result.insert(*(q.reportingFrequency()));
220 }
221 ✗ return result;
222 ✗ }
223
224 ✗ StringSet timeSeriesNames(const SqlFileTimeSeriesQueryVector& queries) {
225 ✗ StringSet result;
226 ✗ for (const SqlFileTimeSeriesQuery& q : queries) {
227 ✗ if (!q.vetted()) {
228 ✗ return {};
229 }
230 ✗ OS_ASSERT(q.timeSeries().get().name());
231 ✗ result.insert(*(q.timeSeries().get().name()));
232 }
233 ✗ return result;
234 ✗ }
235
236 } // namespace openstudio
237