GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 59.8% 52 / 0 / 87
Functions: 67.9% 19 / 0 / 28
Branches: 40.0% 32 / 0 / 80

src/model/SetpointManagerScheduledDualSetpoint.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 "SetpointManagerScheduledDualSetpoint.hpp"
7 #include "SetpointManagerScheduledDualSetpoint_Impl.hpp"
8
9 #include "Schedule.hpp"
10 #include "Schedule_Impl.hpp"
11 #include "Node.hpp"
12 #include "Node_Impl.hpp"
13 #include "PlantLoop.hpp"
14 #include "ScheduleTypeLimits.hpp"
15 #include "ScheduleTypeRegistry.hpp"
16
17 #include <utilities/idd/IddFactory.hxx>
18
19 #include <utilities/idd/OS_SetpointManager_Scheduled_DualSetpoint_FieldEnums.hxx>
20 #include <utilities/idd/IddEnums.hxx>
21
22 #include "../utilities/core/Assert.hpp"
23
24 namespace openstudio {
25 namespace model {
26
27 namespace detail {
28
29 6 SetpointManagerScheduledDualSetpoint_Impl::SetpointManagerScheduledDualSetpoint_Impl(const IdfObject& idfObject, Model_Impl* model,
30 6 bool keepHandle)
31 6 : SetpointManager_Impl(idfObject, model, keepHandle) {
32
4/6
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
✗ Branch 13 not taken.
6 OS_ASSERT(idfObject.iddObject().type() == SetpointManagerScheduledDualSetpoint::iddObjectType());
33 6 }
34
35 ✗ SetpointManagerScheduledDualSetpoint_Impl::SetpointManagerScheduledDualSetpoint_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
36 ✗ Model_Impl* model, bool keepHandle)
37 ✗ : SetpointManager_Impl(other, model, keepHandle) {
38 ✗ OS_ASSERT(other.iddObject().type() == SetpointManagerScheduledDualSetpoint::iddObjectType());
39 ✗ }
40
41 2 SetpointManagerScheduledDualSetpoint_Impl::SetpointManagerScheduledDualSetpoint_Impl(const SetpointManagerScheduledDualSetpoint_Impl& other,
42 2 Model_Impl* model, bool keepHandle)
43 2 : SetpointManager_Impl(other, model, keepHandle) {}
44
45 ✗ const std::vector<std::string>& SetpointManagerScheduledDualSetpoint_Impl::outputVariableNames() const {
46 ✗ static const std::vector<std::string> result;
47 ✗ return result;
48 }
49
50 ✗ IddObjectType SetpointManagerScheduledDualSetpoint_Impl::iddObjectType() const {
51 ✗ return SetpointManagerScheduledDualSetpoint::iddObjectType();
52 }
53
54 ✗ std::vector<ScheduleTypeKey> SetpointManagerScheduledDualSetpoint_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
55 ✗ std::vector<ScheduleTypeKey> result;
56 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
57 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
58 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
59 ✗ if (std::find(b, e, OS_SetpointManager_Scheduled_DualSetpointFields::HighSetpointScheduleName) != e) {
60 ✗ result.push_back(ScheduleTypeKey("SetpointManagerScheduledDualSetpoint", "High Setpoint"));
61 }
62 ✗ if (std::find(b, e, OS_SetpointManager_Scheduled_DualSetpointFields::LowSetpointScheduleName) != e) {
63 ✗ result.push_back(ScheduleTypeKey("SetpointManagerScheduledDualSetpoint", "Low Setpoint"));
64 }
65 ✗ return result;
66 ✗ }
67
68 /** This SPM is allowed on a PlantLoop */
69 1 bool SetpointManagerScheduledDualSetpoint_Impl::isAllowedOnPlantLoop() const {
70 1 return true;
71 }
72
73 4 std::string SetpointManagerScheduledDualSetpoint_Impl::controlVariable() const {
74
1/1
✓ Branch 1 taken 4 times.
4 boost::optional<std::string> value = getString(OS_SetpointManager_Scheduled_DualSetpointFields::ControlVariable, true);
75
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
4 OS_ASSERT(value);
76
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 return value.get();
77 4 }
78
79 6 boost::optional<Schedule> SetpointManagerScheduledDualSetpoint_Impl::highSetpointSchedule() const {
80
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_SetpointManager_Scheduled_DualSetpointFields::HighSetpointScheduleName);
81 }
82
83 4 boost::optional<Schedule> SetpointManagerScheduledDualSetpoint_Impl::lowSetpointSchedule() const {
84
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_SetpointManager_Scheduled_DualSetpointFields::LowSetpointScheduleName);
85 }
86
87 9 boost::optional<Node> SetpointManagerScheduledDualSetpoint_Impl::setpointNode() const {
88
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
9 return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_Scheduled_DualSetpointFields::SetpointNodeorNodeListName);
89 }
90
91 5 bool SetpointManagerScheduledDualSetpoint_Impl::setControlVariable(const std::string& controlVariable) {
92 5 bool result = setString(OS_SetpointManager_Scheduled_DualSetpointFields::ControlVariable, controlVariable);
93 5 return result;
94 }
95
96 5 bool SetpointManagerScheduledDualSetpoint_Impl::setHighSetpointSchedule(Schedule& schedule) {
97
3/3
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
20 bool result = setSchedule(OS_SetpointManager_Scheduled_DualSetpointFields::HighSetpointScheduleName, "SetpointManagerScheduledDualSetpoint",
98 "High Setpoint", schedule);
99 5 return result;
100 }
101
102 ✗ void SetpointManagerScheduledDualSetpoint_Impl::resetHighSetpointSchedule() {
103 ✗ bool result = setString(OS_SetpointManager_Scheduled_DualSetpointFields::HighSetpointScheduleName, "");
104 ✗ OS_ASSERT(result);
105 ✗ }
106
107 5 bool SetpointManagerScheduledDualSetpoint_Impl::setLowSetpointSchedule(Schedule& schedule) {
108
3/3
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
20 bool result = setSchedule(OS_SetpointManager_Scheduled_DualSetpointFields::LowSetpointScheduleName, "SetpointManagerScheduledDualSetpoint",
109 "Low Setpoint", schedule);
110 5 return result;
111 }
112
113 ✗ void SetpointManagerScheduledDualSetpoint_Impl::resetLowSetpointSchedule() {
114 ✗ bool result = setString(OS_SetpointManager_Scheduled_DualSetpointFields::LowSetpointScheduleName, "");
115 ✗ OS_ASSERT(result);
116 ✗ }
117
118 5 bool SetpointManagerScheduledDualSetpoint_Impl::setSetpointNode(const Node& node) {
119
2/2
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
5 return setPointer(OS_SetpointManager_Scheduled_DualSetpointFields::SetpointNodeorNodeListName, node.handle());
120 }
121
122 1 void SetpointManagerScheduledDualSetpoint_Impl::resetSetpointNode() {
123
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_SetpointManager_Scheduled_DualSetpointFields::SetpointNodeorNodeListName, "");
124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
125 1 }
126
127 } // namespace detail
128
129 6 SetpointManagerScheduledDualSetpoint::SetpointManagerScheduledDualSetpoint(const Model& model)
130 6 : SetpointManager(SetpointManagerScheduledDualSetpoint::iddObjectType(), model) {
131
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✗ Branch 5 not taken.
6 OS_ASSERT(getImpl<detail::SetpointManagerScheduledDualSetpoint_Impl>());
132 6 }
133
134 7614 IddObjectType SetpointManagerScheduledDualSetpoint::iddObjectType() {
135
1/1
✓ Branch 1 taken 7614 times.
7614 return {IddObjectType::OS_SetpointManager_Scheduled_DualSetpoint};
136 }
137
138 ✗ std::vector<std::string> SetpointManagerScheduledDualSetpoint::controlVariableValues() {
139 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_SetpointManager_Scheduled_DualSetpointFields::ControlVariable);
140 }
141
142 6 boost::optional<Schedule> SetpointManagerScheduledDualSetpoint::highSetpointSchedule() const {
143
1/1
✓ Branch 3 taken 6 times.
6 return getImpl<detail::SetpointManagerScheduledDualSetpoint_Impl>()->highSetpointSchedule();
144 }
145
146 4 boost::optional<Schedule> SetpointManagerScheduledDualSetpoint::lowSetpointSchedule() const {
147
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::SetpointManagerScheduledDualSetpoint_Impl>()->lowSetpointSchedule();
148 }
149
150 5 bool SetpointManagerScheduledDualSetpoint::setHighSetpointSchedule(Schedule& schedule) {
151
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::SetpointManagerScheduledDualSetpoint_Impl>()->setHighSetpointSchedule(schedule);
152 }
153
154 ✗ void SetpointManagerScheduledDualSetpoint::resetHighSetpointSchedule() {
155 ✗ return getImpl<detail::SetpointManagerScheduledDualSetpoint_Impl>()->resetHighSetpointSchedule();
156 }
157
158 5 bool SetpointManagerScheduledDualSetpoint::setLowSetpointSchedule(Schedule& schedule) {
159
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::SetpointManagerScheduledDualSetpoint_Impl>()->setLowSetpointSchedule(schedule);
160 }
161
162 ✗ void SetpointManagerScheduledDualSetpoint::resetLowSetpointSchedule() {
163 ✗ return getImpl<detail::SetpointManagerScheduledDualSetpoint_Impl>()->resetLowSetpointSchedule();
164 }
165
166 /// @cond
167 7 SetpointManagerScheduledDualSetpoint::SetpointManagerScheduledDualSetpoint(std::shared_ptr<detail::SetpointManagerScheduledDualSetpoint_Impl> impl)
168
1/1
✓ Branch 3 taken 7 times.
7 : SetpointManager(std::move(impl)) {}
169 /// @endcond
170
171 } // namespace model
172 } // namespace openstudio
173