OdbDesign
OdbDesign ODB++ Parser - C++ library, gRPC/REST server, CLI, tests
 
Loading...
Searching...
No Matches
StepDirectory.cpp
Go to the documentation of this file.
1#include "StepDirectory.h"
2#include <filesystem>
3#include "LayerDirectory.h"
4#include <fstream>
5#include <sstream>
6#include "Logger.h"
7#include <memory>
8#include "../../Text/Utf8Sanitizer.h"
9
10
12{
13 StepDirectory::StepDirectory(std::filesystem::path path)
14 : m_path(path)
15 {
16 }
17
19 {
20 m_layersByName.clear();
21 m_netlistsByName.clear();
22 }
23
25 {
26 return m_name;
27 }
28
29 std::filesystem::path StepDirectory::GetPath()
30 {
31 return m_path;
32 }
33
34 const EdaDataFile& StepDirectory::GetEdaDataFile() const { return m_edaData; }
35 const LayerDirectory::StringMap& StepDirectory::GetLayersByName() const { return m_layersByName; }
36 const NetlistFile::StringMap& StepDirectory::GetNetlistsByName() const { return m_netlistsByName; }
37
39 {
40 return m_attrListFile;
41 }
42
44 {
45 return m_profileFile;
46 }
47
49 {
50 return m_stepHdrFile;
51 }
52
54 {
55 if (!std::filesystem::exists(m_path)) return false;
56 else if (!std::filesystem::is_directory(m_path)) return false;
57
58 m_name = std::filesystem::path(m_path).filename().string();
59
60 loginfo("Parsing step directory: " + m_name + "...");
61
62 auto layersPath = m_path / "layers";
63 if (!ParseLayerFiles(layersPath)) return false;
64
65 auto netlistsPath = m_path / "netlists";
66 if (!ParseNetlistFiles(netlistsPath)) return false;
67
68 auto edaPath = m_path / "eda";
69 if (!ParseEdaDataFiles(edaPath)) return false;
70
71 auto attrListPath = m_path;
72 if (!ParseAttrListFile(attrListPath)) return false;
73
74 auto profilePath = m_path;
75 if (!ParseProfileFile(profilePath)) return false;
76
77 auto stepHdrPath = m_path;
78 if (!ParseStepHdrFile(stepHdrPath)) return false;
79
80 loginfo("Parsing step directory: " + m_name + " complete");
81
82 return true;
83 }
84
85 bool StepDirectory::ParseLayerFiles(std::filesystem::path layersPath)
86 {
87 loginfo("Parsing layer directories...");
88
89 if (!std::filesystem::exists(layersPath)) return false;
90 else if (!std::filesystem::is_directory(layersPath)) return false;
91
92 for (auto& d : std::filesystem::directory_iterator(layersPath))
93 {
94 if (std::filesystem::is_directory(d))
95 {
96 auto pLayer = std::make_shared<LayerDirectory>(d.path());
97 if (pLayer->Parse())
98 {
99 loginfo("Parsing layer: " + pLayer->GetName() + " complete");
100
101 m_layersByName[pLayer->GetName()] = pLayer;
102 }
103 else
104 {
105 return false;
106 }
107 }
108 }
109
110 loginfo("Parsing layer directories complete");
111
112 return true;
113 }
114
115 bool StepDirectory::ParseEdaDataFiles(std::filesystem::path edaPath)
116 {
117 loginfo("Parsing eda/data file...");
118
119 if (!std::filesystem::exists(edaPath)) return false;
120 else if (!std::filesystem::is_directory(edaPath)) return false;
121
122 // parse nets and packages definitions
123 auto success = m_edaData.Parse(edaPath);
124
125 loginfo("Parsing eda/data file complete");
126
127 return success;
128 }
129
130 bool StepDirectory::ParseAttrListFile(std::filesystem::path attrListFileDirectory)
131 {
132 loginfo("Parsing attrlist file...");
133
134 if (!std::filesystem::exists(attrListFileDirectory)) return false;
135 if (!std::filesystem::is_directory(attrListFileDirectory)) return false;
136
137 // parse nets and packages definitions
138 auto success = m_attrListFile.Parse(attrListFileDirectory);
139
140 loginfo("Parsing attrlist file complete");
141
142 return success;
143 }
144
145 bool StepDirectory::ParseProfileFile(std::filesystem::path profileFileDirectory)
146 {
147 loginfo("Parsing profile file...");
148
149 if (!std::filesystem::exists(profileFileDirectory)) return false;
150 if (!std::filesystem::is_directory(profileFileDirectory)) return false;
151
152 // parse nets and packages definitions
153 auto success = m_profileFile.Parse(profileFileDirectory, PROFILE_FILENAME);
154
155 loginfo("Parsing profile file complete");
156
157 return success;
158 }
159
160 bool StepDirectory::ParseStepHdrFile(std::filesystem::path stepHdrFileDirectory)
161 {
162 loginfo("Parsing stephdr file...");
163
164 if (!std::filesystem::exists(stepHdrFileDirectory)) return false;
165 if (!std::filesystem::is_directory(stepHdrFileDirectory)) return false;
166
167 // parse nets and packages definitions
168 auto success = m_stepHdrFile.Parse(stepHdrFileDirectory);
169
170 loginfo("Parsing stephdr file complete");
171
172 return success;
173 }
174
175 bool StepDirectory::Save(const std::filesystem::path& directory)
176 {
177 auto stepDir = directory / m_name;
178 if (!create_directory(stepDir)) return false;
179
180 // eda/data
181 auto edaPath = stepDir / "eda";
182 if (!create_directory(edaPath)) return false;
183 std::ofstream edaDataFile(edaPath / "data");
184 if (!m_edaData.Save(edaDataFile)) return false;
185 edaDataFile.close();
186
187 // attrlist
188 std::ofstream attrlistFile(stepDir / "attrlist");
189 if (!m_attrListFile.Save(attrlistFile)) return false;
190 attrlistFile.close();
191
192 // profile
193 std::ofstream profileFile(stepDir / "profile");
194 if (!m_profileFile.Save(profileFile)) return false;
195 profileFile.close();
196
197 // StepHdrFile
198 std::ofstream stephdrFile(stepDir / "stephdr");
199 if (!m_stepHdrFile.Save(stephdrFile)) return false;
200 stephdrFile.close();
201
202 // layers
203 auto layersPath = stepDir / "layers";
204 if (!create_directory(layersPath)) return false;
205 for (auto& kvLayer : m_layersByName)
206 {
207 if (!kvLayer.second->Save(layersPath)) return false;
208 }
209
210 // m_netlistsByName;
211 auto netlistsPath = stepDir / "netlists";
212 if (!create_directory(netlistsPath)) return false;
213 for (auto& kvNetlist : m_netlistsByName)
214 {
215 if (!kvNetlist.second->Save(netlistsPath)) return false;
216 }
217
218 return true;
219 }
220
221 std::unique_ptr<Odb::Lib::Protobuf::StepDirectory> StepDirectory::to_protobuf() const
222 {
223 std::unique_ptr<Odb::Lib::Protobuf::StepDirectory> pStepDirectoryMessage(new Odb::Lib::Protobuf::StepDirectory);
224 FillProtobufMessage(*pStepDirectoryMessage, /*layerSkeletons=*/false);
225 return pStepDirectoryMessage;
226 }
227
228 std::unique_ptr<Odb::Lib::Protobuf::StepDirectory> StepDirectory::to_protobuf_skeleton() const
229 {
230 std::unique_ptr<Odb::Lib::Protobuf::StepDirectory> pStepDirectoryMessage(new Odb::Lib::Protobuf::StepDirectory);
231 FillProtobufMessage(*pStepDirectoryMessage, /*layerSkeletons=*/true);
232 return pStepDirectoryMessage;
233 }
234
235 void StepDirectory::FillProtobufMessage(Odb::Lib::Protobuf::StepDirectory& stepDirectoryMessage, bool layerSkeletons) const
236 {
237 stepDirectoryMessage.set_name(Odb::Lib::Text::ToUtf8(m_name));
238 stepDirectoryMessage.set_path(Odb::Lib::Text::ToUtf8(m_path.string()));
239 stepDirectoryMessage.mutable_edadatafile()->CopyFrom(*m_edaData.to_protobuf());
240 stepDirectoryMessage.mutable_attrlistfile()->CopyFrom(*m_attrListFile.to_protobuf());
241 stepDirectoryMessage.mutable_profilefile()->CopyFrom(*m_profileFile.to_protobuf());
242 stepDirectoryMessage.mutable_stephdrfile()->CopyFrom(*m_stepHdrFile.to_protobuf());
243
244 for (const auto& kvNetlistFile : m_netlistsByName)
245 {
246 (*stepDirectoryMessage.mutable_netlistsbyname())[Odb::Lib::Text::ToUtf8(kvNetlistFile.first)] = *kvNetlistFile.second->to_protobuf();
247 }
248
249 for (const auto& kvLayerDirectoryRecord : m_layersByName)
250 {
251 // No conditional operator here: MSVC's lowering of
252 // `cond ? f() : g()` for move-only prvalues (both returning
253 // unique_ptr) synthesizes a copy of the deleted copy constructor
254 // (C2280); GCC/Clang merge the prvalues per the standard.
255 if (layerSkeletons)
256 {
257 (*stepDirectoryMessage.mutable_layersbyname())[Odb::Lib::Text::ToUtf8(kvLayerDirectoryRecord.first)] =
258 *kvLayerDirectoryRecord.second->to_protobuf_skeleton();
259 }
260 else
261 {
262 (*stepDirectoryMessage.mutable_layersbyname())[Odb::Lib::Text::ToUtf8(kvLayerDirectoryRecord.first)] =
263 *kvLayerDirectoryRecord.second->to_protobuf();
264 }
265 }
266 }
267
268 void StepDirectory::from_protobuf(const Odb::Lib::Protobuf::StepDirectory& message)
269 {
270 m_name = message.name();
271 m_path = message.path();
272 m_edaData.from_protobuf(message.edadatafile());
273 m_attrListFile.from_protobuf(message.attrlistfile());
274 m_profileFile.from_protobuf(message.profilefile());
275 m_stepHdrFile.from_protobuf(message.stephdrfile());
276
277 for (const auto& kvNetlistFile : message.netlistsbyname())
278 {
279 auto pNetlistFile = std::make_shared<NetlistFile>(std::filesystem::path(kvNetlistFile.second.path()));
280 pNetlistFile->from_protobuf(kvNetlistFile.second);
281 m_netlistsByName[kvNetlistFile.first] = pNetlistFile;
282 }
283
284 for (const auto& kvLayerDirectoryRecord : message.layersbyname())
285 {
286 auto pLayerDirectory = std::make_shared<LayerDirectory>(std::filesystem::path(kvLayerDirectoryRecord.second.path()));
287 pLayerDirectory->from_protobuf(kvLayerDirectoryRecord.second);
288 m_layersByName[kvLayerDirectoryRecord.first] = pLayerDirectory;
289 }
290 }
291
292 bool StepDirectory::ParseNetlistFiles(std::filesystem::path netlistsPath)
293 {
294 loginfo("Parsing netlist files...");
295
296 std::size_t netListDirectoriesFound = 0;
297
298 if (std::filesystem::exists(netlistsPath))
299 {
300 if (std::filesystem::is_directory(netlistsPath))
301 {
302 // parse net name records
303 for (auto& d : std::filesystem::directory_iterator(netlistsPath))
304 {
305 if (std::filesystem::is_directory(d))
306 {
307 netListDirectoriesFound++;
308
309 auto pNetlist = std::make_shared<NetlistFile>(d.path());
310 if (pNetlist->Parse())
311 {
312 m_netlistsByName[pNetlist->GetName()] = pNetlist;
313 }
314 else
315 {
316 // pNetList will be freed when exiting the above scope
317 logerror("Failed to parse netlist directory: " + pNetlist->GetName());
318 }
319 }
320 }
321 }
322 }
323
324 if (netListDirectoriesFound == 0) // netlist dirs found, but none parsed successfully
325 {
326 logwarn("No netlist directories found");
327 }
328 else if (netListDirectoriesFound == m_netlistsByName.size())
329 {
330 loginfo("netlist directories parsed successfully");
331 }
332
333 return true;
334 }
335
337 {
338 auto findIt = m_layersByName.find(ComponentsFile::TOP_COMPONENTS_LAYER_NAME);
339 if (findIt != m_layersByName.end())
340 {
341 return &(findIt->second->GetComponentsFile());
342 }
343 else
344 {
345 return nullptr;
346 }
347 }
348
350 {
351 auto findIt = m_layersByName.find(ComponentsFile::BOTTOM_COMPONENTS_LAYER_NAME);
352 if (findIt != m_layersByName.end())
353 {
354 return &(findIt->second->GetComponentsFile());
355 }
356 else
357 {
358 return nullptr;
359 }
360 }
361}
#define logerror(s)
Definition Logger.h:17
#define logwarn(s)
Definition Logger.h:20
#define loginfo(s)
Definition Logger.h:14
bool Parse(std::filesystem::path directory)
void from_protobuf(const Odb::Lib::Protobuf::AttrListFile &message) override
std::unique_ptr< Odb::Lib::Protobuf::AttrListFile > to_protobuf() const override
bool Save(std::ostream &os) override
static constexpr const char * TOP_COMPONENTS_LAYER_NAME
static constexpr const char * BOTTOM_COMPONENTS_LAYER_NAME
bool Save(std::ostream &os) override
void from_protobuf(const Odb::Lib::Protobuf::EdaDataFile &message) override
std::unique_ptr< Odb::Lib::Protobuf::EdaDataFile > to_protobuf() const override
bool Parse(std::filesystem::path path)
bool Parse(std::filesystem::path directory, const std::string &alternateFilename="")
void from_protobuf(const Odb::Lib::Protobuf::FeaturesFile &message) override
bool Save(std::ostream &os) override
std::unique_ptr< Odb::Lib::Protobuf::FeaturesFile > to_protobuf() const override
std::map< std::string, std::shared_ptr< LayerDirectory > > StringMap
std::map< std::string, std::shared_ptr< NetlistFile > > StringMap
std::unique_ptr< Odb::Lib::Protobuf::StepDirectory > to_protobuf_skeleton() const
void from_protobuf(const Odb::Lib::Protobuf::StepDirectory &message) override
std::unique_ptr< Odb::Lib::Protobuf::StepDirectory > to_protobuf() const override
const ComponentsFile * GetTopComponentsFile() const
StepDirectory(std::filesystem::path path)
const FeaturesFile & GetProfileFile() const
const StepHdrFile & GetStepHdrFile() const
const ComponentsFile * GetBottomComponentsFile() const
const NetlistFile::StringMap & GetNetlistsByName() const
const LayerDirectory::StringMap & GetLayersByName() const
const AttrListFile & GetAttrListFile() const
const EdaDataFile & GetEdaDataFile() const
bool Save(const std::filesystem::path &directory) override
std::unique_ptr< Odb::Lib::Protobuf::StepHdrFile > to_protobuf() const override
bool Save(std::ostream &os) override
void from_protobuf(const Odb::Lib::Protobuf::StepHdrFile &message) override
bool Parse(std::filesystem::path path) override
std::string ToUtf8(std::string_view input)
Converts input to valid UTF-8.