KiCad PCB EDA Suite
Loading...
Searching...
No Matches
footprint_info_impl.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2011 Jean-Pierre Charras, <[email protected]>
5 * Copyright (C) 2013-2016 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
6 * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
7 *
8 * This program is free software: you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22
23#include <footprint_info_impl.h>
24
26#include <footprint.h>
27#include <footprint_info.h>
28#include <fp_lib_table.h>
29#include <kiway.h>
30#include <locale_io.h>
31#include <lib_id.h>
32#include <progress_reporter.h>
33#include <string_utils.h>
34#include <core/thread_pool.h>
36
37#include <kiplatform/io.h>
38
39#include <wx/textfile.h>
40#include <wx/txtstrm.h>
41#include <wx/wfstream.h>
42
43
45{
46 FP_LIB_TABLE* fptable = m_owner->GetTable();
47
48 wxASSERT( fptable );
49
50 const FOOTPRINT* footprint = fptable->GetEnumeratedFootprint( m_nickname, m_fpname );
51
52 if( footprint == nullptr ) // Should happen only with malformed/broken libraries
53 {
54 m_pad_count = 0;
56 }
57 else
58 {
61 m_keywords = footprint->GetKeywords();
62 m_doc = footprint->GetLibDescription();
63 }
64
65 m_loaded = true;
66}
67
68
69bool FOOTPRINT_LIST_IMPL::CatchErrors( const std::function<void()>& aFunc )
70{
71 try
72 {
73 aFunc();
74 }
75 catch( const IO_ERROR& ioe )
76 {
77 m_errors.move_push( std::make_unique<IO_ERROR>( ioe ) );
78 return false;
79 }
80 catch( const std::exception& se )
81 {
82 // This is a round about way to do this, but who knows what THROW_IO_ERROR()
83 // may be tricked out to do someday, keep it in the game.
84 try
85 {
86 THROW_IO_ERROR( se.what() );
87 }
88 catch( const IO_ERROR& ioe )
89 {
90 m_errors.move_push( std::make_unique<IO_ERROR>( ioe ) );
91 }
92
93 return false;
94 }
95
96 return true;
97}
98
99
100bool FOOTPRINT_LIST_IMPL::ReadFootprintFiles( FP_LIB_TABLE* aTable, const wxString* aNickname,
101 PROGRESS_REPORTER* aProgressReporter )
102{
103 long long int generatedTimestamp = 0;
104
105 if( !CatchErrors( [&]()
106 {
107 generatedTimestamp = aTable->GenerateTimestamp( aNickname );
108 } ) )
109 {
110 return false;
111 }
112
113 if( generatedTimestamp == m_list_timestamp )
114 return true;
115
116 // Disable KIID generation: not needed for library parts; sometimes very slow
117 KIID_NIL_SET_RESET reset_kiid;
118
119 m_progress_reporter = aProgressReporter;
120
122 {
124 m_progress_reporter->Report( _( "Fetching footprint libraries..." ) );
125 }
126
127 m_cancelled = false;
128 m_lib_table = aTable;
129
130 // Clear data before reading files
131 m_errors.clear();
132 m_list.clear();
135
136 if( aNickname )
137 {
138 m_queue_in.push( *aNickname );
139 }
140 else
141 {
142 for( const wxString& nickname : aTable->GetLogicalLibs() )
143 m_queue_in.push( nickname );
144 }
145
146
147 loadLibs();
148
149 if( !m_cancelled )
150 {
152 {
155 m_progress_reporter->Report( _( "Loading footprints..." ) );
156 }
157
159
162 }
163
164 if( m_cancelled )
165 m_list_timestamp = 0; // God knows what we got before we were canceled
166 else
167 m_list_timestamp = generatedTimestamp;
168
169 return m_errors.empty();
170}
171
172
174{
176 size_t num_returns = m_queue_in.size();
177 std::vector<std::future<size_t>> returns( num_returns );
178
179 auto loader_job =
180 [this]() -> size_t
181 {
182 wxString nickname;
183 size_t retval = 0;
184
185 if( !m_cancelled && m_queue_in.pop( nickname ) )
186 {
187 if( CatchErrors( [this, &nickname]()
188 {
189 m_lib_table->PrefetchLib( nickname );
190 m_queue_out.push( nickname );
191 } ) && m_progress_reporter )
192 {
194 }
195
196 ++retval;
197 }
198
199 return retval;
200 };
201
202 for( size_t ii = 0; ii < num_returns; ++ii )
203 returns[ii] = tp.submit( loader_job );
204
205 for( const std::future<size_t>& ret : returns )
206 {
207 std::future_status status = ret.wait_for( std::chrono::milliseconds( 250 ) );
208
209 while( status != std::future_status::ready )
210 {
212 m_cancelled = true;
213
214 status = ret.wait_for( std::chrono::milliseconds( 250 ) );
215 }
216 }
217}
218
219
221{
222 LOCALE_IO toggle_locale;
223
224 // Parse the footprints in parallel. WARNING! This requires changing the locale, which is
225 // GLOBAL. It is only thread safe to construct the LOCALE_IO before the threads are created,
226 // destroy it after they finish, and block the main (GUI) thread while they work. Any deviation
227 // from this will cause nasal demons.
228 //
229 // TODO: blast LOCALE_IO into the sun
230
233 size_t num_elements = m_queue_out.size();
234 std::vector<std::future<size_t>> returns( num_elements );
235
236 auto fp_thread =
237 [ this, &queue_parsed ]() -> size_t
238 {
239 wxString nickname;
240
241 if( m_cancelled || !m_queue_out.pop( nickname ) )
242 return 0;
243
244 wxArrayString fpnames;
245
247 [&]()
248 {
249 m_lib_table->FootprintEnumerate( fpnames, nickname, false );
250 } );
251
252 for( wxString fpname : fpnames )
253 {
255 [&]()
256 {
257 auto* fpinfo = new FOOTPRINT_INFO_IMPL( this, nickname, fpname );
258 queue_parsed.move_push( std::unique_ptr<FOOTPRINT_INFO>( fpinfo ) );
259 } );
260
261 if( m_cancelled )
262 return 0;
263 }
264
267
268 return 1;
269 };
270
271 for( size_t ii = 0; ii < num_elements; ++ii )
272 returns[ii] = tp.submit( fp_thread );
273
274 for( const std::future<size_t>& ret : returns )
275 {
276 std::future_status status = ret.wait_for( std::chrono::milliseconds( 250 ) );
277
278 while( status != std::future_status::ready )
279 {
282
283 status = ret.wait_for( std::chrono::milliseconds( 250 ) );
284 }
285 }
286
287 std::unique_ptr<FOOTPRINT_INFO> fpi;
288
289 while( queue_parsed.pop( fpi ) )
290 m_list.push_back( std::move( fpi ) );
291
292 std::sort( m_list.begin(), m_list.end(),
293 []( std::unique_ptr<FOOTPRINT_INFO> const& lhs,
294 std::unique_ptr<FOOTPRINT_INFO> const& rhs ) -> bool
295 {
296 return *lhs < *rhs;
297 } );
298}
299
300
302 m_list_timestamp( 0 ),
303 m_progress_reporter( nullptr ),
304 m_cancelled( false )
305{
306}
307
308
309void FOOTPRINT_LIST_IMPL::WriteCacheToFile( const wxString& aFilePath )
310{
311 wxFileName tmpFileName = wxFileName::CreateTempFileName( aFilePath );
312 wxFFileOutputStream outStream( tmpFileName.GetFullPath() );
313 wxTextOutputStream txtStream( outStream );
314
315 if( !outStream.IsOk() )
316 {
317 return;
318 }
319
320 txtStream << wxString::Format( wxT( "%lld" ), m_list_timestamp ) << endl;
321
322 for( std::unique_ptr<FOOTPRINT_INFO>& fpinfo : m_list )
323 {
324 txtStream << fpinfo->GetLibNickname() << endl;
325 txtStream << fpinfo->GetName() << endl;
326 txtStream << EscapeString( fpinfo->GetDescription(), CTX_LINE ) << endl;
327 txtStream << EscapeString( fpinfo->GetKeywords(), CTX_LINE ) << endl;
328 txtStream << wxString::Format( wxT( "%d" ), fpinfo->GetOrderNum() ) << endl;
329 txtStream << wxString::Format( wxT( "%u" ), fpinfo->GetPadCount() ) << endl;
330 txtStream << wxString::Format( wxT( "%u" ), fpinfo->GetUniquePadCount() ) << endl;
331 }
332
333 txtStream.Flush();
334 outStream.Close();
335
336 // Preserve the permissions of the current file
337 KIPLATFORM::IO::DuplicatePermissions( aFilePath, tmpFileName.GetFullPath() );
338
339 if( !wxRenameFile( tmpFileName.GetFullPath(), aFilePath, true ) )
340 {
341 // cleanup in case rename failed
342 // its also not the end of the world since this is just a cache file
343 wxRemoveFile( tmpFileName.GetFullPath() );
344 }
345}
346
347
348void FOOTPRINT_LIST_IMPL::ReadCacheFromFile( const wxString& aFilePath )
349{
350 wxTextFile cacheFile( aFilePath );
351
353 m_list.clear();
354
355 try
356 {
357 if( cacheFile.Exists() && cacheFile.Open() )
358 {
359 cacheFile.GetFirstLine().ToLongLong( &m_list_timestamp );
360
361 while( cacheFile.GetCurrentLine() + 6 < cacheFile.GetLineCount() )
362 {
363 wxString libNickname = cacheFile.GetNextLine();
364 wxString name = cacheFile.GetNextLine();
365 wxString desc = UnescapeString( cacheFile.GetNextLine() );
366 wxString keywords = UnescapeString( cacheFile.GetNextLine() );
367 int orderNum = wxAtoi( cacheFile.GetNextLine() );
368 unsigned int padCount = (unsigned) wxAtoi( cacheFile.GetNextLine() );
369 unsigned int uniquePadCount = (unsigned) wxAtoi( cacheFile.GetNextLine() );
370
371 FOOTPRINT_INFO_IMPL* fpinfo = new FOOTPRINT_INFO_IMPL( libNickname, name, desc,
372 keywords, orderNum,
373 padCount, uniquePadCount );
374
375 m_list.emplace_back( std::unique_ptr<FOOTPRINT_INFO>( fpinfo ) );
376 }
377 }
378 }
379 catch( ... )
380 {
381 // whatever went wrong, invalidate the cache
383 }
384
385 // Sanity check: an empty list is very unlikely to be correct.
386 if( m_list.size() == 0 )
388
389 if( cacheFile.IsOpened() )
390 cacheFile.Close();
391}
const char * name
Definition: DXF_plotter.cpp:57
virtual void load() override
lazily load stuff not filled in by constructor. This may throw IO_ERRORS.
wxString m_doc
Footprint description.
wxString m_fpname
Module name.
wxString m_keywords
Footprint keywords.
unsigned m_unique_pad_count
Number of unique pads.
unsigned m_pad_count
Number of pads.
FOOTPRINT_LIST * m_owner
provides access to FP_LIB_TABLE
wxString m_nickname
library as known in FP_LIB_TABLE
bool ReadFootprintFiles(FP_LIB_TABLE *aTable, const wxString *aNickname=nullptr, PROGRESS_REPORTER *aProgressReporter=nullptr) override
Read all the footprints provided by the combination of aTable and aNickname.
std::atomic_bool m_cancelled
SYNC_QUEUE< wxString > m_queue_in
bool CatchErrors(const std::function< void()> &aFunc)
Call aFunc, pushing any IO_ERRORs and std::exceptions it throws onto m_errors.
void WriteCacheToFile(const wxString &aFilePath) override
void ReadCacheFromFile(const wxString &aFilePath) override
PROGRESS_REPORTER * m_progress_reporter
SYNC_QUEUE< wxString > m_queue_out
FP_LIB_TABLE * m_lib_table
no ownership
ERRLIST m_errors
some can be PARSE_ERRORs also
FP_LIB_TABLE * GetTable() const
wxString GetLibDescription() const
Definition: footprint.h:236
unsigned GetPadCount(INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) const
Return the number of pads.
Definition: footprint.cpp:1572
unsigned GetUniquePadCount(INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) const
Return the number of unique non-blank pads.
Definition: footprint.cpp:1622
wxString GetKeywords() const
Definition: footprint.h:239
void FootprintEnumerate(wxArrayString &aFootprintNames, const wxString &aNickname, bool aBestEfforts)
Return a list of footprint names contained within the library given by aNickname.
const FOOTPRINT * GetEnumeratedFootprint(const wxString &aNickname, const wxString &aFootprintName)
A version of FootprintLoad() for use after FootprintEnumerate() for more efficient cache management.
long long GenerateTimestamp(const wxString *aNickname)
Generate a hashed timestamp representing the last-mod-times of the library indicated by aNickname,...
void PrefetchLib(const wxString &aNickname)
If possible, prefetches the specified library (e.g.
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
RAII class to safely set/reset nil KIIDs for use in footprint/symbol loading.
Definition: kiid.h:214
std::vector< wxString > GetLogicalLibs()
Return the logical library names, all of them that are pertinent to a look up done on this LIB_TABLE.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:49
A progress reporter interface for use in multi-threaded environments.
virtual bool KeepRefreshing(bool aWait=false)=0
Update the UI (if any).
virtual void Report(const wxString &aMessage)=0
Display aMessage in the progress bar dialog.
virtual void AdvancePhase()=0
Use the next available virtual zone of the dialog progress bar.
virtual void AdvanceProgress()=0
Increment the progress bar length (inside the current virtual zone).
virtual void SetMaxProgress(int aMaxProgress)=0
Fix the value that gives the 100 percent progress bar length (inside the current virtual zone).
Synchronized, locking queue.
Definition: sync_queue.h:32
bool pop(T &aReceiver)
Pop a value if the queue into the provided variable.
Definition: sync_queue.h:63
bool empty() const
Return true if the queue is empty.
Definition: sync_queue.h:82
void clear()
Clear the queue.
Definition: sync_queue.h:100
size_t size() const
Return the size of the queue.
Definition: sync_queue.h:91
void push(T const &aValue)
Push a value onto the queue.
Definition: sync_queue.h:41
void move_push(T &&aValue)
Move a value onto the queue.
Definition: sync_queue.h:50
#define _(s)
@ DO_NOT_INCLUDE_NPTH
Definition: footprint.h:61
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
bool DuplicatePermissions(const wxString &aSrc, const wxString &aDest)
Duplicates the file security data from one file to another ensuring that they are the same between bo...
Definition: gtk/io.cpp:40
wxString UnescapeString(const wxString &aSource)
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
@ CTX_LINE
Definition: string_utils.h:59
static thread_pool * tp
Definition: thread_pool.cpp:30
BS::thread_pool thread_pool
Definition: thread_pool.h:30
thread_pool & GetKiCadThreadPool()
Get a reference to the current thread pool.
Definition: thread_pool.cpp:32
Definition of file extensions used in Kicad.