altium_pcb_compound_file.cpp

Go to the documentation of this file.

#include <altium_pcb_compound_file.h>
#include <utf.h>
 
#include <wx/string.h>
 
#include <compoundfilereader.h>
#include <map>
 
ALTIUM_PCB_COMPOUND_FILE::ALTIUM_PCB_COMPOUND_FILE( const wxString& aFilePath )
 : ALTIUM_COMPOUND_FILE( aFilePath )
{
}
 
ALTIUM_PCB_COMPOUND_FILE::ALTIUM_PCB_COMPOUND_FILE( const void* aBuffer, size_t aLen )
 : ALTIUM_COMPOUND_FILE( aBuffer, aLen )
{
}
 
 
ALTIUM_PCB_COMPOUND_FILE::~ALTIUM_PCB_COMPOUND_FILE()
{
}
 
std::map<wxString, wxString> ALTIUM_PCB_COMPOUND_FILE::ListLibFootprints()
{
 if( m_libFootprintDirNameCache.empty() )
 cacheLibFootprintNames();
 
 return m_libFootprintDirNameCache;
}
 
 
std::tuple<wxString, const CFB::COMPOUND_FILE_ENTRY*>
ALTIUM_PCB_COMPOUND_FILE::FindLibFootprintDirName( const wxString& aFpUnicodeName )
{
 if( m_libFootprintNameCache.empty() )
 cacheLibFootprintNames();
 
 auto it = m_libFootprintNameCache.find( aFpUnicodeName );
 
 if( it == m_libFootprintNameCache.end() )
 return { wxEmptyString, nullptr };
 
 return { it->first, it->second };
}
 
 
const std::pair<AMODEL, std::vector<char>>* ALTIUM_PCB_COMPOUND_FILE::GetLibModel( const wxString& aModelName ) const
{
 auto it = m_libModelsCache.find( aModelName );
 
 if( it == m_libModelsCache.end() )
 return nullptr;
 
 return &it->second;
}
 
 
void ALTIUM_PCB_COMPOUND_FILE::cacheLibFootprintNames()
{
 m_libFootprintDirNameCache.clear();
 m_libFootprintNameCache.clear();
 
 if( !m_reader )
 return;
 
 const CFB::COMPOUND_FILE_ENTRY* root = m_reader->GetRootEntry();
 
 if( !root )
 return;
 
 m_reader->EnumFiles( root, 1,
 [this]( const CFB::COMPOUND_FILE_ENTRY* tentry, const CFB::utf16string& dir, int level ) -> int
 {
 if( m_reader->IsStream( tentry ) )
 return 0;
 
 m_reader->EnumFiles( tentry, 1,
 [&]( const CFB::COMPOUND_FILE_ENTRY* entry, const CFB::utf16string&, int ) -> int
 {
 std::wstring fileName = UTF16ToWstring( entry->name, entry->nameLen );
 
 if( m_reader->IsStream( entry ) && fileName == L"Parameters" )
 {
 ALTIUM_BINARY_PARSER parametersReader( *this, entry );
 std::map<wxString, wxString> parameterProperties =
 parametersReader.ReadProperties();
 
 wxString key = ALTIUM_PROPS_UTILS::ReadString(
 parameterProperties, wxT( "PATTERN" ), wxT( "" ) );
 wxString fpName = ALTIUM_PROPS_UTILS::ReadUnicodeString(
 parameterProperties, wxT( "PATTERN" ), wxT( "" ) );
 
 m_libFootprintDirNameCache[key] = fpName;
 m_libFootprintNameCache[fpName] = tentry;
 }
 
 return 0;
 } );
 return 0;
 } );
}
 
 
bool ALTIUM_PCB_COMPOUND_FILE::CacheLibModels()
{
 const CFB::COMPOUND_FILE_ENTRY* models_root = nullptr;
 const CFB::COMPOUND_FILE_ENTRY* models_data = nullptr;
 bool found = false;
 
 if( !m_reader || !m_libModelsCache.empty() )
 return false;
 
 models_data = FindStream( { "Library", "Models", "Data" } );
 
 if( !models_data )
 return false;
 
 ALTIUM_BINARY_PARSER parser( *this, models_data );
 
 if( parser.GetRemainingBytes() == 0 )
 return false;
 
 std::vector<AMODEL> models;
 
 // First, we parse and extract the model data from the Data stream
 while( parser.GetRemainingBytes() >= 4 )
 {
 AMODEL elem( parser );
 models.push_back( elem );
 }
 
 // Next, we need the model directory entry to read the compressed model streams
 m_reader->EnumFiles( m_reader->GetRootEntry(), 2, [&]( const CFB::COMPOUND_FILE_ENTRY* entry, const CFB::utf16string& dir, int ) -> int
 {
 if( found )
 return 1;
 
 if( m_reader->IsStream( entry ) )
 return 0;
 
 std::string dir_str = UTF16ToUTF8( dir.c_str() );
 std::string entry_str = UTF16ToUTF8( entry->name );
 
 if( dir_str.compare( "Library" ) == 0 && entry_str.compare( "Models" ) == 0 )
 {
 models_root = entry;
 found = true;
 return 1;
 }
 
 return 0;
 });
 
 if( !models_root )
 return false;
 
 m_reader->EnumFiles(
 models_root, 1,
 [&]( const CFB::COMPOUND_FILE_ENTRY* stepEntry, const CFB::utf16string&, int ) -> int
 {
 long fileNumber;
 wxString fileName = UTF16ToUTF8( stepEntry->name, stepEntry->nameLen );
 
 if( !fileName.ToLong( &fileNumber ) )
 return 0;
 
 
 if( !m_reader->IsStream( stepEntry ) || fileNumber >= long( models.size() ) )
 return 0;
 
 size_t stepSize = static_cast<size_t>( stepEntry->size );
 std::vector<char> stepContent( stepSize );
 
 // read file into buffer
 m_reader->ReadFile( stepEntry, 0, stepContent.data(), stepSize );
 
 if( stepContent.empty() )
 return 0;
 
 // We store the models in their original compressed form so as to speed the caching process
 // When we parse an individual footprint, we decompress and recompress the model data into
 // our format
 m_libModelsCache.emplace( models[fileNumber].id,
 std::make_pair( std::move( models[fileNumber] ),
 std::move( stepContent ) ) );
 return 0;
 } );
 
 return true;
}