GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 0.0% 0 / 0 / 82
Functions: 0.0% 0 / 0 / 39
Branches: 0.0% 0 / 0 / 31

src/modelica/ModelicaFile.cpp
Line Branch Exec Source
1 #include "ModelicaFile.hpp"
2 #include "ModelicaFileImpl.hpp"
3 #include <stdexcept>
4
5 namespace openstudio::modelica {
6
7 // ModelicaFile implementation
8
9 ✗ ModelicaFile::ModelicaFile(const openstudio::path& path) : m_impl(std::make_shared<detail::ModelicaFileImpl>(path)) {}
10
11 ✗ ModelicaFile::ModelicaFile(const ModelicaFile& other) = default;
12
13 ✗ ModelicaFile::ModelicaFile(ModelicaFile&& other) noexcept = default;
14
15 ✗ ModelicaFile& ModelicaFile::operator=(const ModelicaFile& other) = default;
16
17 ✗ ModelicaFile& ModelicaFile::operator=(ModelicaFile&& other) noexcept = default;
18
19 ✗ ModelicaFile::~ModelicaFile() = default;
20
21 ✗ void ModelicaFile::parse(const std::string& text) {
22 ✗ m_impl->parse(text);
23 ✗ }
24
25 ✗ std::string ModelicaFile::getText() const {
26 ✗ return m_impl->getText();
27 }
28
29 ✗ std::string ModelicaFile::printTree() const {
30 ✗ return m_impl->printTree();
31 }
32
33 ✗ std::vector<ClassDefinition> ModelicaFile::getClassDefinitions() {
34 ✗ auto implClasses = m_impl->getClassDefinitions();
35 ✗ std::vector<ClassDefinition> result;
36 ✗ result.reserve(implClasses.size());
37
38 ✗ for (auto* implClass : implClasses) {
39 ✗ result.emplace_back(ClassDefinition(implClass));
40 }
41
42 ✗ return result;
43 ✗ }
44
45 ✗ ClassDefinition ModelicaFile::getClassDefinitionByName(const std::string& name) {
46 ✗ auto* implClass = m_impl->getClassDefinitionByName(name);
47 ✗ return ClassDefinition(implClass);
48 }
49
50 ✗ ClassDefinition ModelicaFile::addClassDefinition(const std::string& text) {
51 ✗ auto* implClass = m_impl->addClassDefinition(text);
52 ✗ return ClassDefinition(implClass);
53 }
54
55 // ClassDefinition implementation
56
57 ✗ ClassDefinition::ClassDefinition() : m_impl(nullptr) {}
58
59 ✗ ClassDefinition::ClassDefinition(const ClassDefinition& other) = default;
60
61 ✗ ClassDefinition::ClassDefinition(ClassDefinition&& other) noexcept = default;
62
63 ✗ ClassDefinition& ClassDefinition::operator=(const ClassDefinition& other) = default;
64
65 ✗ ClassDefinition& ClassDefinition::operator=(ClassDefinition&& other) noexcept = default;
66
67 ✗ ClassDefinition::~ClassDefinition() = default;
68
69 ✗ ClassDefinition::ClassDefinition(detail::ClassDefinitionImpl* impl) : m_impl(impl) {}
70
71 ✗ std::string ClassDefinition::longClassSpecifier() const {
72 ✗ return implChecked("longClassSpecifier")->longClassSpecifier();
73 }
74
75 ✗ std::string ClassDefinition::getText() const {
76 ✗ return implChecked("getText")->getText();
77 }
78
79 ✗ void ClassDefinition::addComponentClause(const std::string& text) const {
80 ✗ implChecked("addComponentClause")->addComponentClause(text);
81 ✗ }
82
83 ✗ std::vector<ConnectClause> ClassDefinition::getConnectClauses() const {
84 ✗ auto* impl = implChecked("getConnectClauses");
85 ✗ auto implConnections = impl->getConnectClauses();
86 ✗ std::vector<ConnectClause> result;
87 ✗ result.reserve(implConnections.size());
88 ✗ for (auto* connection : implConnections) {
89 ✗ result.emplace_back(ConnectClause(connection));
90 }
91 ✗ return result;
92 ✗ }
93
94 ✗ ConnectClause ClassDefinition::addConnectClause(const std::string& source, const std::string& target) const {
95 ✗ auto* implConnection = implChecked("addConnectClause")->addConnectClause(source, target);
96 ✗ return ConnectClause(implConnection);
97 }
98
99 ✗ bool ClassDefinition::removeConnectClause(const std::string& source, const std::string& target) const {
100 ✗ return implChecked("removeConnectClause")->removeConnectClause(source, target);
101 }
102
103 ✗ bool ClassDefinition::isValid() const {
104 ✗ return m_impl && m_impl->isActive();
105 }
106
107 // ConnectClause implementation
108
109 ✗ ConnectClause::ConnectClause() : m_impl(nullptr) {}
110
111 ✗ ConnectClause::ConnectClause(const ConnectClause& other) = default;
112
113 ✗ ConnectClause::ConnectClause(ConnectClause&& other) noexcept = default;
114
115 ✗ ConnectClause& ConnectClause::operator=(const ConnectClause& other) = default;
116
117 ✗ ConnectClause& ConnectClause::operator=(ConnectClause&& other) noexcept = default;
118
119 ✗ ConnectClause::~ConnectClause() = default;
120
121 ✗ ConnectClause::ConnectClause(detail::ConnectClauseImpl* impl) : m_impl(impl) {}
122
123 ✗ std::string ConnectClause::source() const {
124 ✗ return implChecked("source")->source();
125 }
126
127 ✗ std::string ConnectClause::target() const {
128 ✗ return implChecked("target")->target();
129 }
130
131 ✗ void ConnectClause::remove() {
132 ✗ implChecked("remove")->remove();
133 ✗ m_impl = nullptr;
134 ✗ }
135
136 ✗ bool ConnectClause::isValid() const {
137 ✗ return m_impl && m_impl->isActive();
138 }
139
140 ✗ detail::ClassDefinitionImpl* ClassDefinition::implChecked(const char* methodName) const {
141 ✗ if (!isValid()) {
142 ✗ throw std::runtime_error(std::string("ClassDefinition handle is no longer valid; reacquire before calling ") + methodName);
143 }
144 ✗ return m_impl;
145 }
146
147 ✗ detail::ConnectClauseImpl* ConnectClause::implChecked(const char* methodName) const {
148 ✗ if (!isValid()) {
149 ✗ throw std::runtime_error(std::string("ConnectClause handle is no longer valid; reacquire before calling ") + methodName);
150 }
151 ✗ return m_impl;
152 }
153
154 } // namespace openstudio::modelica
155