symbol_async_loader.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2021 Jon Evans <[email protected]>
 * Copyright (C) 2021-2022 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <thread>
 
#include <core/wx_stl_compat.h>
#include <symbol_async_loader.h>
#include <symbol_lib_table.h>
#include <progress_reporter.h>
 
 
SYMBOL_ASYNC_LOADER::SYMBOL_ASYNC_LOADER( const std::vector<wxString>& aNicknames,
 SYMBOL_LIB_TABLE* aTable, bool aOnlyPowerSymbols,
 std::unordered_map<wxString, std::vector<LIB_SYMBOL*>>* aOutput,
 PROGRESS_REPORTER* aReporter ) :
 m_nicknames( aNicknames ),
 m_table( aTable ),
 m_onlyPowerSymbols( aOnlyPowerSymbols ),
 m_output( aOutput ),
 m_reporter( aReporter ),
 m_nextLibrary( 0 )
{
 wxASSERT( m_table );
 m_threadCount = std::max<size_t>( 1, std::thread::hardware_concurrency() );
 
 m_returns.resize( m_threadCount );
}
 
 
 
SYMBOL_ASYNC_LOADER::~SYMBOL_ASYNC_LOADER()
{
 Join();
}
 
 
void SYMBOL_ASYNC_LOADER::Start()
{
 for( size_t ii = 0; ii < m_threadCount; ++ii )
 m_returns[ii] = std::async( std::launch::async, &SYMBOL_ASYNC_LOADER::worker, this );
}
 
 
bool SYMBOL_ASYNC_LOADER::Join()
{
 for( size_t ii = 0; ii < m_threadCount; ++ii )
 {
 if( !m_returns[ii].valid() )
 continue;
 
 m_returns[ii].wait();
 
 const std::vector<LOADED_PAIR>& ret = m_returns[ii].get();
 
 if( m_output && !ret.empty() )
 {
 for( const LOADED_PAIR& pair : ret )
 {
 // Don't show libraries that had no power symbols
 if( m_onlyPowerSymbols && pair.second.empty() )
 continue;
 
 // *Do* show empty libraries in the normal case
 m_output->insert( pair );
 }
 }
 }
 
 return true;
}
 
 
bool SYMBOL_ASYNC_LOADER::Done()
{
 return m_nextLibrary.load() >= m_nicknames.size();
}
 
 
std::vector<SYMBOL_ASYNC_LOADER::LOADED_PAIR> SYMBOL_ASYNC_LOADER::worker()
{
 std::vector<LOADED_PAIR> ret;
 
 bool onlyPower = m_onlyPowerSymbols;
 
 for( size_t libraryIndex = m_nextLibrary++; libraryIndex < m_nicknames.size();
 libraryIndex = m_nextLibrary++ )
 {
 const wxString& nickname = m_nicknames[libraryIndex];
 
 if( m_reporter )
 m_reporter->AdvancePhase( wxString::Format( _( "Loading library %s..." ), nickname ) );
 
 if( m_reporter && m_reporter->IsCancelled() )
 break;
 
 LOADED_PAIR pair( nickname, {} );
 
 try
 {
 m_table->LoadSymbolLib( pair.second, nickname, onlyPower );
 ret.emplace_back( std::move( pair ) );
 }
 catch( const IO_ERROR& ioe )
 {
 wxString msg = wxString::Format( _( "Error loading symbol library %s.\n\n%s\n" ),
 nickname, ioe.What() );
 
 std::lock_guard<std::mutex> lock( m_errorMutex );
 m_errors += msg;
 }
 catch( std::exception& e )
 {
 wxString msg = wxString::Format( _( "Error loading symbol library %s.\n\n%s\n" ),
 nickname, e.what() );
 
 std::lock_guard<std::mutex> lock( m_errorMutex );
 m_errors += msg;
 }
 }
 
 return ret;
}