BOARD_NETLIST_UPDATER Class Reference

Update the BOARD with a new netlist. More...

#include <board_netlist_updater.h>

Public Member Functions
	BOARD_NETLIST_UPDATER (PCB_EDIT_FRAME *aFrame, BOARD *aBoard)
	~BOARD_NETLIST_UPDATER ()
bool	UpdateNetlist (NETLIST &aNetlist)
	Update the board's components according to the new netlist. More...
void	SetReporter (REPORTER *aReporter)
	Enable "delete single pad nets" option. More...
void	SetDeleteSinglePadNets (bool aEnabled)
	Enable warning option if a connectable pad is not found in netlist connectable = pad with a name and on a copper layer. More...
void	SetWarnPadNoNetInNetlist (bool aEnabled)
	Enable dry run mode (just report, no changes to PCB). More...
void	SetIsDryRun (bool aEnabled)
	Enable replacing footprints with new ones. More...
void	SetReplaceFootprints (bool aEnabled)
	Enable removing unused components. More...
void	SetDeleteUnusedComponents (bool aEnabled)
	Enable component lookup by timestamp instead of reference. More...
void	SetLookupByTimestamp (bool aEnabled)
std::vector< FOOTPRINT * >	GetAddedComponents () const

Private Member Functions
void	cacheNetname (PAD *aPad, const wxString &aNetname)
wxString	getNetname (PAD *aPad)
void	cachePinFunction (PAD *aPad, const wxString &aPinFunction)
wxString	getPinFunction (PAD *aPad)
wxPoint	estimateComponentInsertionPosition ()
FOOTPRINT *	addNewComponent (COMPONENT *aComponent)
FOOTPRINT *	replaceComponent (NETLIST &aNetlist, FOOTPRINT *aPcbComponent, COMPONENT *aNewComponent)
bool	updateFootprintParameters (FOOTPRINT *aPcbFootprint, COMPONENT *aNetlistComponent)
bool	updateComponentPadConnections (FOOTPRINT *aFootprint, COMPONENT *aNewComponent)
void	cacheCopperZoneConnections ()
bool	updateCopperZoneNets (NETLIST &aNetlist)
bool	deleteUnusedComponents (NETLIST &aNetlist)
bool	deleteSinglePadNets ()
bool	testConnectivity (NETLIST &aNetlist, std::map< COMPONENT *, FOOTPRINT * > &aFootprintMap)

Private Attributes
PCB_EDIT_FRAME *	m_frame
BOARD_COMMIT	m_commit
BOARD *	m_board
REPORTER *	m_reporter
std::map< ZONE *, std::vector< PAD * > >	m_zoneConnectionsCache
std::map< wxString, wxString >	m_oldToNewNets
std::map< PAD *, wxString >	m_padNets
std::map< PAD *, wxString >	m_padPinFunctions
std::vector< FOOTPRINT * >	m_addedComponents
std::map< wxString, NETINFO_ITEM * >	m_addedNets
bool	m_deleteSinglePadNets
bool	m_deleteUnusedComponents
bool	m_isDryRun
bool	m_replaceFootprints
bool	m_lookupByTimestamp
bool	m_warnForNoNetPads
int	m_warningCount
int	m_errorCount
int	m_newFootprintsCount

Detailed Description

Update the BOARD with a new netlist.

The changes are made to the board are as follows they are not disabled in the status settings in the NETLIST:

• If a new component is found in the NETLIST and not in the BOARD, it is added to the BOARD.
• If a the component in the NETLIST is already on the BOARD, then one or more of the following actions can occur:
  • If the footprint name in the NETLIST does not match the footprint name on the BOARD, the footprint on the BOARD is replaced with the footprint specified in the NETLIST and the proper parameters are copied from the existing footprint.
  • If the reference designator in the NETLIST does not match the reference designator on the BOARD, the reference designator is updated from the NETLIST.
  • If the value field in the NETLIST does not match the value field on the BOARD, the value field is updated from the NETLIST.
  • If the time stamp in the NETLIST does not match the time stamp on the BOARD, the time stamp is updated from the NETLIST.
• After each footprint is added or update as described above, each footprint pad net name is compared and updated to the value defined in the NETLIST.
• After all of the footprints have been added, updated, and net names and pin function properly set, any extra unlock footprints are removed from the BOARD.

Definition at line 71 of file board_netlist_updater.h.

Constructor & Destructor Documentation

BOARD_NETLIST_UPDATER()

BOARD_NETLIST_UPDATER::BOARD_NETLIST_UPDATER	(	PCB_EDIT_FRAME *	aFrame,
		BOARD *	aBoard
	)

Definition at line 48 of file board_netlist_updater.cpp.

                                                                                    :
    m_frame( aFrame ),
    m_commit( aFrame ),
    m_board( aBoard )
{
    m_reporter = &NULL_REPORTER::GetInstance();

    m_deleteSinglePadNets = true;
    m_deleteUnusedComponents = false;
    m_isDryRun = false;
    m_replaceFootprints = true;
    m_lookupByTimestamp = false;
    m_warnForNoNetPads = false;

    m_warningCount = 0;
    m_errorCount = 0;
    m_newFootprintsCount = 0;
}

References NULL_REPORTER::GetInstance(), m_deleteSinglePadNets, m_deleteUnusedComponents, m_errorCount, m_isDryRun, m_lookupByTimestamp, m_newFootprintsCount, m_replaceFootprints, m_reporter, m_warnForNoNetPads, and m_warningCount.

~BOARD_NETLIST_UPDATER()

BOARD_NETLIST_UPDATER::~BOARD_NETLIST_UPDATER

(

)

Definition at line 68 of file board_netlist_updater.cpp.

{
}

Member Function Documentation

addNewComponent()

FOOTPRINT * BOARD_NETLIST_UPDATER::addNewComponent ( COMPONENT *  aComponent )

private

Definition at line 134 of file board_netlist_updater.cpp.

{
    wxString msg;

    if( aComponent->GetFPID().empty() )
    {
        msg.Printf( _( "Cannot add %s (no footprint assigned)." ),
                    aComponent->GetReference(),
                    aComponent->GetFPID().Format().wx_str() );
        m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        ++m_errorCount;
        return nullptr;
    }

    FOOTPRINT* footprint = m_frame->LoadFootprint( aComponent->GetFPID() );

    if( footprint == nullptr )
    {
        msg.Printf( _( "Cannot add %s (footprint \"%s\" not found)." ),
                    aComponent->GetReference(),
                    aComponent->GetFPID().Format().wx_str() );
        m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        ++m_errorCount;
        return nullptr;
    }

    if( m_isDryRun )
    {
        msg.Printf( _( "Add %s (footprint \"%s\")." ),
                    aComponent->GetReference(),
                    aComponent->GetFPID().Format().wx_str() );

        delete footprint;
        footprint = nullptr;
    }
    else
    {
        for( PAD* pad : footprint->Pads() )
        {
            // Set the pads ratsnest settings to the global settings
            pad->SetLocalRatsnestVisible( m_frame->GetDisplayOptions().m_ShowGlobalRatsnest );

            // Pads in the library all have orphaned nets.  Replace with Default.
            pad->SetNetCode( 0 );
        }

        footprint->SetParent( m_board );
        footprint->SetPosition( estimateComponentInsertionPosition( ) );

        m_addedComponents.push_back( footprint );
        m_commit.Add( footprint );

        msg.Printf( _( "Added %s (footprint \"%s\")." ),
                    aComponent->GetReference(),
                    aComponent->GetFPID().Format().wx_str() );
    }

    m_reporter->Report( msg, RPT_SEVERITY_ACTION );
    m_newFootprintsCount++;
    return footprint;
}

References _, COMMIT::Add(), LIB_ID::empty(), estimateComponentInsertionPosition(), LIB_ID::Format(), PCB_BASE_FRAME::GetDisplayOptions(), COMPONENT::GetFPID(), COMPONENT::GetReference(), PCB_BASE_FRAME::LoadFootprint(), m_addedComponents, m_board, m_commit, m_errorCount, m_frame, m_isDryRun, m_newFootprintsCount, m_reporter, PCB_DISPLAY_OPTIONS::m_ShowGlobalRatsnest, pad, FOOTPRINT::Pads(), REPORTER::Report(), RPT_SEVERITY_ACTION, RPT_SEVERITY_ERROR, EDA_ITEM::SetParent(), FOOTPRINT::SetPosition(), and UTF8::wx_str().

Referenced by UpdateNetlist().

cacheCopperZoneConnections()

void BOARD_NETLIST_UPDATER::cacheCopperZoneConnections ( )

private

Definition at line 582 of file board_netlist_updater.cpp.

{
    for( ZONE* zone : m_board->Zones() )
    {
        if( !zone->IsOnCopperLayer() || zone->GetIsRuleArea() )
            continue;

        m_zoneConnectionsCache[ zone ] = m_board->GetConnectivity()->GetConnectedPads( zone );
    }
}

References BOARD::GetConnectivity(), m_board, m_zoneConnectionsCache, and BOARD::Zones().

Referenced by UpdateNetlist().

cacheNetname()

void BOARD_NETLIST_UPDATER::cacheNetname ( PAD *  aPad, const wxString &  aNetname  )

private

Definition at line 76 of file board_netlist_updater.cpp.

{
    m_padNets[ aPad ] = aNetname;
}

References m_padNets.

Referenced by deleteSinglePadNets(), and updateComponentPadConnections().

cachePinFunction()

void BOARD_NETLIST_UPDATER::cachePinFunction ( PAD *  aPad, const wxString &  aPinFunction  )

private

Definition at line 91 of file board_netlist_updater.cpp.

{
    m_padPinFunctions[ aPad ] = aPinFunction;
}

References m_padPinFunctions.

Referenced by updateComponentPadConnections().

deleteSinglePadNets()

bool BOARD_NETLIST_UPDATER::deleteSinglePadNets ( )

private

Definition at line 772 of file board_netlist_updater.cpp.

{
    int       count = 0;
    wxString  netname;
    wxString  msg;
    PAD*      previouspad = NULL;

    // We need the pad list for next tests.

    m_board->BuildListOfNets();

    std::vector<PAD*> padlist = m_board->GetPads();

    // Sort pads by netlist name
    std::sort( padlist.begin(), padlist.end(),
               [ this ]( PAD* a, PAD* b ) -> bool
               {
                   return getNetname( a ) < getNetname( b );
               } );

    for( PAD* pad : padlist )
    {
        if( getNetname( pad ).IsEmpty() )
            continue;

        if( netname != getNetname( pad ) )  // End of net
        {
            if( previouspad && count == 1 )
            {
                // First, see if we have a copper zone attached to this pad.
                // If so, this is not really a single pad net

                for( ZONE* zone : m_board->Zones() )
                {
                    if( !zone->IsOnCopperLayer() )
                        continue;

                    if( zone->GetIsRuleArea() )
                        continue;

                    if( zone->GetNetname() == getNetname( previouspad ) )
                    {
                        count++;
                        break;
                    }
                }

                if( count == 1 )    // Really one pad, and nothing else
                {
                    if( m_isDryRun )
                    {
                        cacheNetname( previouspad, wxEmptyString );
                        msg.Printf( _( "Remove single pad net %s." ),
                                    UnescapeString( getNetname( previouspad ) ) );
                    }
                    else
                    {
                        previouspad->SetNetCode( NETINFO_LIST::UNCONNECTED );
                        msg.Printf( _( "Removed single pad net %s." ),
                                    UnescapeString( getNetname( previouspad ) ) );
                    }

                    m_reporter->Report( msg, RPT_SEVERITY_ACTION );
                }
            }

            netname = getNetname( pad );
            count = 1;
        }
        else
        {
            count++;
        }

        previouspad = pad;
    }

    // Examine last pad
    if( count == 1 )
    {
        if( !m_isDryRun )
            previouspad->SetNetCode( NETINFO_LIST::UNCONNECTED );
        else
            cacheNetname( previouspad, wxEmptyString );
    }

    return true;
}

References _, BOARD::BuildListOfNets(), cacheNetname(), getNetname(), BOARD::GetPads(), m_board, m_isDryRun, m_reporter, NULL, pad, REPORTER::Report(), RPT_SEVERITY_ACTION, BOARD_CONNECTED_ITEM::SetNetCode(), NETINFO_LIST::UNCONNECTED, UnescapeString(), and BOARD::Zones().

Referenced by UpdateNetlist().

deleteUnusedComponents()

bool BOARD_NETLIST_UPDATER::deleteUnusedComponents ( NETLIST &  aNetlist )

private

estimateComponentInsertionPosition()

wxPoint BOARD_NETLIST_UPDATER::estimateComponentInsertionPosition ( )

private

Definition at line 106 of file board_netlist_updater.cpp.

{
    wxPoint bestPosition;

    if( !m_board->IsEmpty() )
    {
        // Position new components below any existing board features.
        EDA_RECT bbox = m_board->GetBoardEdgesBoundingBox();

        if( bbox.GetWidth() || bbox.GetHeight() )
        {
            bestPosition.x = bbox.Centre().x;
            bestPosition.y = bbox.GetBottom() + Millimeter2iu( 10 );
        }
    }
    else
    {
        // Position new components in the center of the page when the board is empty.
        wxSize pageSize = m_board->GetPageSettings().GetSizeIU();

        bestPosition.x = pageSize.GetWidth() / 2;
        bestPosition.y = pageSize.GetHeight() / 2;
    }

    return bestPosition;
}

References EDA_RECT::Centre(), BOARD::GetBoardEdgesBoundingBox(), EDA_RECT::GetBottom(), EDA_RECT::GetHeight(), BOARD::GetPageSettings(), EDA_RECT::GetWidth(), BOARD::IsEmpty(), m_board, and Millimeter2iu().

Referenced by addNewComponent().

GetAddedComponents()

std::vector<FOOTPRINT*> BOARD_NETLIST_UPDATER::GetAddedComponents ( ) const

inline

Definition at line 130 of file board_netlist_updater.h.

    {
        return m_addedComponents;
    }

References m_addedComponents.

Referenced by PCB_EDIT_FRAME::OnNetlistChanged().

getNetname()

wxString BOARD_NETLIST_UPDATER::getNetname ( PAD *  aPad )

private

Definition at line 82 of file board_netlist_updater.cpp.

{
    if( m_isDryRun && m_padNets.count( aPad ) )
        return m_padNets[ aPad ];
    else
        return aPad->GetNetname();
}

References BOARD_CONNECTED_ITEM::GetNetname(), m_isDryRun, and m_padNets.

Referenced by deleteSinglePadNets(), and updateCopperZoneNets().

getPinFunction()

wxString BOARD_NETLIST_UPDATER::getPinFunction ( PAD *  aPad )

private

Definition at line 97 of file board_netlist_updater.cpp.

{
    if( m_isDryRun && m_padPinFunctions.count( aPad ) )
        return m_padPinFunctions[ aPad ];
    else
        return aPad->GetPinFunction();
}

References PAD::GetPinFunction(), m_isDryRun, and m_padPinFunctions.

replaceComponent()

FOOTPRINT * BOARD_NETLIST_UPDATER::replaceComponent ( NETLIST &  aNetlist, FOOTPRINT *  aPcbComponent, COMPONENT *  aNewComponent  )

private

Definition at line 197 of file board_netlist_updater.cpp.

{
    wxString msg;

    if( aNewComponent->GetFPID().empty() )
    {
        msg.Printf( _( "Cannot update %s (no footprint assigned)." ),
                    aNewComponent->GetReference(),
                    aNewComponent->GetFPID().Format().wx_str() );
        m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        ++m_errorCount;
        return nullptr;
    }

    FOOTPRINT* newFootprint = m_frame->LoadFootprint( aNewComponent->GetFPID() );

    if( newFootprint == nullptr )
    {
        msg.Printf( _( "Cannot update %s (footprint \"%s\" not found)." ),
                    aNewComponent->GetReference(),
                    aNewComponent->GetFPID().Format().wx_str() );
        m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        ++m_errorCount;
        return nullptr;
    }

    if( m_isDryRun )
    {
        msg.Printf( _( "Change %s footprint from '%s' to '%s'."),
                    aPcbComponent->GetReference(),
                    aPcbComponent->GetFPID().Format().wx_str(),
                    aNewComponent->GetFPID().Format().wx_str() );

        delete newFootprint;
        newFootprint = nullptr;
    }
    else
    {
        m_frame->ExchangeFootprint( aPcbComponent, newFootprint, m_commit );

        msg.Printf( _( "Changed %s footprint from '%s' to '%s'."),
                    aPcbComponent->GetReference(),
                    aPcbComponent->GetFPID().Format().wx_str(),
                    aNewComponent->GetFPID().Format().wx_str() );
    }

    m_reporter->Report( msg, RPT_SEVERITY_ACTION );
    m_newFootprintsCount++;
    return newFootprint;
}

References _, LIB_ID::empty(), PCB_EDIT_FRAME::ExchangeFootprint(), LIB_ID::Format(), COMPONENT::GetFPID(), FOOTPRINT::GetFPID(), COMPONENT::GetReference(), FOOTPRINT::GetReference(), PCB_BASE_FRAME::LoadFootprint(), m_commit, m_errorCount, m_frame, m_isDryRun, m_newFootprintsCount, m_reporter, REPORTER::Report(), RPT_SEVERITY_ACTION, RPT_SEVERITY_ERROR, and UTF8::wx_str().

Referenced by UpdateNetlist().

SetDeleteSinglePadNets()

void BOARD_NETLIST_UPDATER::SetDeleteSinglePadNets ( bool  aEnabled )

inline

Enable warning option if a connectable pad is not found in netlist connectable = pad with a name and on a copper layer.

Definition at line 94 of file board_netlist_updater.h.

References m_deleteSinglePadNets.

Referenced by PCB_EDIT_FRAME::KiwayMailIn().

SetDeleteUnusedComponents()

void BOARD_NETLIST_UPDATER::SetDeleteUnusedComponents ( bool  aEnabled )

inline

Enable component lookup by timestamp instead of reference.

Definition at line 119 of file board_netlist_updater.h.

References m_deleteUnusedComponents.

Referenced by PCB_EDIT_FRAME::KiwayMailIn().

SetIsDryRun()

void BOARD_NETLIST_UPDATER::SetIsDryRun ( bool  aEnabled )

inline

Enable replacing footprints with new ones.

Definition at line 107 of file board_netlist_updater.h.

References m_isDryRun.

SetLookupByTimestamp()

void BOARD_NETLIST_UPDATER::SetLookupByTimestamp ( bool  aEnabled )

inline

Definition at line 125 of file board_netlist_updater.h.

    {
        m_lookupByTimestamp = aEnabled;
    }

References m_lookupByTimestamp.

Referenced by PCB_EDIT_FRAME::KiwayMailIn().

SetReplaceFootprints()

void BOARD_NETLIST_UPDATER::SetReplaceFootprints ( bool  aEnabled )

inline

Enable removing unused components.

Definition at line 113 of file board_netlist_updater.h.

References m_replaceFootprints.

Referenced by PCB_EDIT_FRAME::KiwayMailIn().

SetReporter()

void BOARD_NETLIST_UPDATER::SetReporter ( REPORTER *  aReporter )

inline

Enable "delete single pad nets" option.

Definition at line 88 of file board_netlist_updater.h.

References m_reporter.

Referenced by DIALOG_NETLIST::loadNetlist(), and DIALOG_UPDATE_PCB::PerformUpdate().

SetWarnPadNoNetInNetlist()

void BOARD_NETLIST_UPDATER::SetWarnPadNoNetInNetlist ( bool  aEnabled )

inline

Enable dry run mode (just report, no changes to PCB).

Definition at line 101 of file board_netlist_updater.h.

References m_warnForNoNetPads.

Referenced by PCB_EDIT_FRAME::KiwayMailIn().

testConnectivity()

bool BOARD_NETLIST_UPDATER::testConnectivity ( NETLIST &  aNetlist, std::map< COMPONENT *, FOOTPRINT * > &  aFootprintMap  )

private

Definition at line 862 of file board_netlist_updater.cpp.

{
    // Verify that board contains all pads in netlist: if it doesn't then footprints are
    // wrong or missing.

    wxString msg;
    wxString padname;

    for( int i = 0; i < (int) aNetlist.GetCount(); i++ )
    {
        COMPONENT* component = aNetlist.GetComponent( i );
        FOOTPRINT* footprint = aFootprintMap[component];

        if( !footprint )    // It can be missing in partial designs
            continue;

        // Explore all pins/pads in component
        for( unsigned jj = 0; jj < component->GetNetCount(); jj++ )
        {
            const COMPONENT_NET& net = component->GetNet( jj );
            padname = net.GetPinName();

            if( footprint->FindPadByName( padname ) )
                continue;   // OK, pad found

            // not found: bad footprint, report error
            msg.Printf( _( "%s pad %s not found in %s." ),
                        component->GetReference(),
                        padname,
                        footprint->GetFPID().Format().wx_str() );
            m_reporter->Report( msg, RPT_SEVERITY_ERROR );
            ++m_errorCount;
        }
    }

    return true;
}

References _, FOOTPRINT::FindPadByName(), LIB_ID::Format(), NETLIST::GetComponent(), NETLIST::GetCount(), FOOTPRINT::GetFPID(), COMPONENT::GetNet(), COMPONENT::GetNetCount(), COMPONENT_NET::GetPinName(), COMPONENT::GetReference(), m_errorCount, m_reporter, REPORTER::Report(), RPT_SEVERITY_ERROR, and UTF8::wx_str().

Referenced by UpdateNetlist().

updateComponentPadConnections()

bool BOARD_NETLIST_UPDATER::updateComponentPadConnections ( FOOTPRINT *  aFootprint, COMPONENT *  aNewComponent  )

private

Definition at line 401 of file board_netlist_updater.cpp.

{
    wxString msg;

    // Create a copy only if the footprint has not been added during this update
    FOOTPRINT* copy = m_commit.GetStatus( aFootprint ) ? nullptr : (FOOTPRINT*) aFootprint->Clone();
    bool       changed = false;

    // At this point, the component footprint is updated.  Now update the nets.
    for( PAD* pad : aFootprint->Pads() )
    {
        const COMPONENT_NET& net = aNewComponent->GetNet( pad->GetName() );

        wxString pinFunction;
        wxString pinType;

        if( net.IsValid() )     // i.e. the pad has a name
        {
            pinFunction = net.GetPinFunction();
            pinType = net.GetPinType();
        }

        if( !m_isDryRun )
        {
            if( pad->GetPinFunction() != pinFunction )
            {
                changed = true;
                pad->SetPinFunction( pinFunction );
            }

            if( pad->GetPinType() != pinType )
            {
                changed = true;
                pad->SetPinType( pinType );
            }
        }
        else
            cachePinFunction( pad, pinFunction );

        // Test if new footprint pad has no net (pads not on copper layers have no net).
        if( !net.IsValid() || !pad->IsOnCopperLayer() )
        {
            if( !pad->GetNetname().IsEmpty() )
            {
                if( m_isDryRun )
                {
                    msg.Printf( _( "Disconnect %s pin %s." ),
                                aFootprint->GetReference(),
                                pad->GetName() );
                }
                else
                {
                    msg.Printf( _( "Disconnected %s pin %s." ),
                                aFootprint->GetReference(),
                                pad->GetName() );
                }

                m_reporter->Report( msg, RPT_SEVERITY_ACTION );
            }
            else if( m_warnForNoNetPads && pad->IsOnCopperLayer() && !pad->GetName().IsEmpty() )
            {
                // pad is connectable but has no net found in netlist
                msg.Printf( _( "No net found for symbol %s pin %s." ),
                            aFootprint->GetReference(),
                            pad->GetName() );
                m_reporter->Report( msg, RPT_SEVERITY_WARNING);
            }

            if( !m_isDryRun )
            {
                changed = true;
                pad->SetNetCode( NETINFO_LIST::UNCONNECTED );

                // If the pad has no net from netlist (i.e. not in netlist
                // it cannot have a pin function
                if( pad->GetNetname().IsEmpty() )
                    pad->SetPinFunction( wxEmptyString );

            }
            else
                cacheNetname( pad, wxEmptyString );
        }
        else                                 // New footprint pad has a net.
        {
            const wxString& netName = net.GetNetName();
            NETINFO_ITEM* netinfo = m_board->FindNet( netName );

            if( netinfo && !m_isDryRun )
                netinfo->SetIsCurrent( true );

            if( pad->GetNetname() != netName )
            {

                if( netinfo == nullptr )
                {
                    // It might be a new net that has not been added to the board yet
                    if( m_addedNets.count( netName ) )
                        netinfo = m_addedNets[ netName ];
                }

                if( netinfo == nullptr )
                {
                    netinfo = new NETINFO_ITEM( m_board, netName );

                    // It is a new net, we have to add it
                    if( !m_isDryRun )
                    {
                        changed = true;
                        m_commit.Add( netinfo );
                    }

                    m_addedNets[netName] = netinfo;
                    msg.Printf( _( "Add net %s." ), UnescapeString( netName ) );
                    m_reporter->Report( msg, RPT_SEVERITY_ACTION );
                }

                if( !pad->GetNetname().IsEmpty() )
                {
                    m_oldToNewNets[ pad->GetNetname() ] = netName;

                    if( m_isDryRun )
                    {
                        msg.Printf( _( "Reconnect %s pin %s from %s to %s."),
                                    aFootprint->GetReference(),
                                    pad->GetName(),
                                    UnescapeString( pad->GetNetname() ),
                                    UnescapeString( netName ) );
                    }
                    else
                    {
                        msg.Printf( _( "Reconnected %s pin %s from %s to %s."),
                                    aFootprint->GetReference(),
                                    pad->GetName(),
                                    UnescapeString( pad->GetNetname() ),
                                    UnescapeString( netName ) );
                    }
                }
                else
                {
                    if( m_isDryRun )
                    {
                        msg.Printf( _( "Connect %s pin %s to %s."),
                                    aFootprint->GetReference(),
                                    pad->GetName(),
                                    UnescapeString( netName ) );
                    }
                    else
                    {
                        msg.Printf( _( "Connected %s pin %s to %s."),

                                    aFootprint->GetReference(),
                                    pad->GetName(),
                                    UnescapeString( netName ) );
                    }
                }

                m_reporter->Report( msg, RPT_SEVERITY_ACTION );

                if( !m_isDryRun )
                {
                    changed = true;
                    pad->SetNet( netinfo );
                }
                else
                {
                    cacheNetname( pad, netName );
                }
            }
        }
    }

    if( changed && copy )
        m_commit.Modified( aFootprint, copy );
    else
        delete copy;

    return true;
}

References _, COMMIT::Add(), cacheNetname(), cachePinFunction(), FOOTPRINT::Clone(), copy, BOARD::FindNet(), COMPONENT::GetNet(), COMPONENT_NET::GetNetName(), COMPONENT_NET::GetPinFunction(), COMPONENT_NET::GetPinType(), FOOTPRINT::GetReference(), COMMIT::GetStatus(), COMPONENT_NET::IsValid(), m_addedNets, m_board, m_commit, m_isDryRun, m_oldToNewNets, m_reporter, m_warnForNoNetPads, COMMIT::Modified(), pad, FOOTPRINT::Pads(), REPORTER::Report(), RPT_SEVERITY_ACTION, RPT_SEVERITY_WARNING, NETINFO_ITEM::SetIsCurrent(), NETINFO_LIST::UNCONNECTED, and UnescapeString().

Referenced by UpdateNetlist().

updateCopperZoneNets()

bool BOARD_NETLIST_UPDATER::updateCopperZoneNets ( NETLIST &  aNetlist )

private

Definition at line 594 of file board_netlist_updater.cpp.

{
    wxString msg;
    std::set<wxString> netlistNetnames;

    for( int ii = 0; ii < (int) aNetlist.GetCount(); ii++ )
    {
        const COMPONENT* component = aNetlist.GetComponent( ii );
        for( unsigned jj = 0; jj < component->GetNetCount(); jj++ )
        {
            const COMPONENT_NET& net = component->GetNet( jj );
            netlistNetnames.insert( net.GetNetName() );
        }
    }

    for( TRACK* via : m_board->Tracks() )
    {
        if( via->Type() != PCB_VIA_T )
            continue;

        if( netlistNetnames.count( via->GetNetname() ) == 0 )
        {
            wxString updatedNetname = wxEmptyString;

            // Take via name from name change map if it didn't match to a new pad
            // (this is useful for stitching vias that don't connect to tracks)
            if( m_oldToNewNets.count( via->GetNetname() ) )
            {
                updatedNetname = m_oldToNewNets[via->GetNetname()];
            }

            if( !updatedNetname.IsEmpty() )
            {
                if( m_isDryRun )
                {
                    msg.Printf( _( "Reconnect via from %s to %s." ),
                                UnescapeString( via->GetNetname() ),
                                UnescapeString( updatedNetname ) );

                    m_reporter->Report( msg, RPT_SEVERITY_ACTION );
                }
                else
                {
                    NETINFO_ITEM* netinfo = m_board->FindNet( updatedNetname );

                    if( !netinfo )
                        netinfo = m_addedNets[updatedNetname];

                    if( netinfo )
                    {
                        m_commit.Modify( via );
                        via->SetNet( netinfo );

                        msg.Printf( _( "Reconnected via from %s to %s." ),
                                    UnescapeString( via->GetNetname() ),
                                    UnescapeString( updatedNetname ) );

                        m_reporter->Report( msg, RPT_SEVERITY_ACTION );
                    }
                }
            }
            else
            {
                msg.Printf( _( "Via connected to unknown net (%s)." ),
                            UnescapeString( via->GetNetname() ) );
                m_reporter->Report( msg, RPT_SEVERITY_WARNING );
                ++m_warningCount;
            }
        }
    }

    // Test copper zones to detect "dead" nets (nets without any pad):
    for( ZONE* zone : m_board->Zones() )
    {
        if( !zone->IsOnCopperLayer() || zone->GetIsRuleArea() )
            continue;

        if( netlistNetnames.count( zone->GetNetname() ) == 0 )
        {
            // Look for a pad in the zone's connected-pad-cache which has been updated to
            // a new net and use that. While this won't always be the right net, the dead
            // net is guaranteed to be wrong.
            wxString updatedNetname = wxEmptyString;

            for( PAD* pad : m_zoneConnectionsCache[ zone ] )
            {
                if( getNetname( pad ) != zone->GetNetname() )
                {
                    updatedNetname = getNetname( pad );
                    break;
                }
            }

            // Take zone name from name change map if it didn't match to a new pad
            // (this is useful for zones on internal layers)
            if( updatedNetname.IsEmpty() && m_oldToNewNets.count( zone->GetNetname() ) )
            {
                updatedNetname = m_oldToNewNets[ zone->GetNetname() ];
            }

            if( !updatedNetname.IsEmpty() )
            {
                if( m_isDryRun )
                {
                    if( !zone->GetZoneName().IsEmpty() )
                    {
                        msg.Printf( _( "Reconnect copper zone '%s' from %s to %s." ),
                                    zone->GetZoneName(),
                                    UnescapeString( zone->GetNetname() ),
                                    UnescapeString( updatedNetname ) );
                    }
                    else
                    {
                        msg.Printf( _( "Reconnect copper zone from %s to %s." ),
                                    UnescapeString( zone->GetNetname() ),
                                    UnescapeString( updatedNetname ) );
                    }

                    m_reporter->Report( msg, RPT_SEVERITY_ACTION );
                }
                else
                {
                    NETINFO_ITEM* netinfo = m_board->FindNet( updatedNetname );

                    if( !netinfo )
                        netinfo = m_addedNets[ updatedNetname ];

                    if( netinfo )
                    {
                        m_commit.Modify( zone );
                        zone->SetNet( netinfo );

                        if( !zone->GetZoneName().IsEmpty() )
                        {
                            msg.Printf( _( "Reconnected copper zone '%s' from %s to %s." ),
                                        zone->GetZoneName(),
                                        UnescapeString( zone->GetNetname() ),
                                        UnescapeString( updatedNetname ) );
                        }
                        else
                        {
                            msg.Printf( _( "Reconnected copper zone from %s to %s." ),
                                        UnescapeString( zone->GetNetname() ),
                                        UnescapeString( updatedNetname ) );
                        }

                        m_reporter->Report( msg, RPT_SEVERITY_ACTION );
                    }
                }
            }
            else
            {
                if( !zone->GetZoneName().IsEmpty() )
                {
                    msg.Printf( _( "Copper zone '%s' has no pads connected." ),
                                zone->GetZoneName() );
                }
                else
                {
                    PCB_LAYER_ID layer = zone->GetLayer();
                    wxPoint      pos = zone->GetPosition();

                    msg.Printf( _( "Copper zone on layer %s at (%s, %s) has no pads connected." ),
                                m_board->GetLayerName( layer ),
                                MessageTextFromValue( m_frame->GetUserUnits(), pos.x ),
                                MessageTextFromValue( m_frame->GetUserUnits(), pos.y ) );
                }

                m_reporter->Report( msg, RPT_SEVERITY_WARNING );
                ++m_warningCount;
            }
        }
    }

    return true;
}

References _, BOARD::FindNet(), NETLIST::GetComponent(), NETLIST::GetCount(), BOARD::GetLayerName(), COMPONENT::GetNet(), COMPONENT::GetNetCount(), COMPONENT_NET::GetNetName(), getNetname(), EDA_BASE_FRAME::GetUserUnits(), m_addedNets, m_board, m_commit, m_frame, m_isDryRun, m_oldToNewNets, m_reporter, m_warningCount, m_zoneConnectionsCache, MessageTextFromValue(), COMMIT::Modify(), pad, PCB_VIA_T, REPORTER::Report(), RPT_SEVERITY_ACTION, RPT_SEVERITY_WARNING, BOARD::Tracks(), UnescapeString(), via, and BOARD::Zones().

Referenced by UpdateNetlist().

updateFootprintParameters()

bool BOARD_NETLIST_UPDATER::updateFootprintParameters ( FOOTPRINT *  aPcbFootprint, COMPONENT *  aNetlistComponent  )

private

Definition at line 250 of file board_netlist_updater.cpp.

{
    wxString msg;

    // Create a copy only if the footprint has not been added during this update
    FOOTPRINT* copy = m_commit.GetStatus( aPcbFootprint ) ? nullptr
                                                          : (FOOTPRINT*) aPcbFootprint->Clone();
    bool       changed = false;

    // Test for reference designator field change.
    if( aPcbFootprint->GetReference() != aNetlistComponent->GetReference() )
    {
        if( m_isDryRun )
        {
            msg.Printf( _( "Change %s reference designator to %s." ),
                        aPcbFootprint->GetReference(),
                        aNetlistComponent->GetReference() );
        }
        else
        {
            msg.Printf( _( "Changed %s reference designator to %s." ),
                        aPcbFootprint->GetReference(),
                        aNetlistComponent->GetReference() );

            changed = true;
            aPcbFootprint->SetReference( aNetlistComponent->GetReference() );
        }

        m_reporter->Report( msg, RPT_SEVERITY_ACTION );
    }

    // Test for value field change.
    if( aPcbFootprint->GetValue() != aNetlistComponent->GetValue() )
    {
        if( m_isDryRun )
        {
            msg.Printf( _( "Change %s value from %s to %s." ),
                        aPcbFootprint->GetReference(),
                        aPcbFootprint->GetValue(),
                        aNetlistComponent->GetValue() );
        }
        else
        {
            msg.Printf( _( "Changed %s value from %s to %s." ),
                        aPcbFootprint->GetReference(),
                        aPcbFootprint->GetValue(),
                        aNetlistComponent->GetValue() );

            changed = true;
            aPcbFootprint->SetValue( aNetlistComponent->GetValue() );
        }

        m_reporter->Report( msg, RPT_SEVERITY_ACTION );
    }

    // Test for time stamp change.
    KIID_PATH new_path = aNetlistComponent->GetPath();
    new_path.push_back( aNetlistComponent->GetKIIDs().front() );

    if( aPcbFootprint->GetPath() != new_path )
    {
        if( m_isDryRun )
        {
            msg.Printf( _( "Update %s symbol association from %s to %s." ),
                        aPcbFootprint->GetReference(),
                        aPcbFootprint->GetPath().AsString(),
                        new_path.AsString() );
        }
        else
        {
            msg.Printf( _( "Updated %s symbol association from %s to %s." ),
                        aPcbFootprint->GetReference(),
                        aPcbFootprint->GetPath().AsString(),
                        new_path.AsString() );

            changed = true;
            aPcbFootprint->SetPath( new_path );
        }

        m_reporter->Report( msg, RPT_SEVERITY_ACTION );
    }

    if( aPcbFootprint->GetProperties() != aNetlistComponent->GetProperties() )
    {
        if( m_isDryRun )
        {
            msg.Printf( _( "Update %s properties." ),
                        aPcbFootprint->GetReference() );
        }
        else
        {
            msg.Printf( _( "Updated %s properties." ),
                        aPcbFootprint->GetReference() );

            changed = true;
            aPcbFootprint->SetProperties( aNetlistComponent->GetProperties() );
        }

        m_reporter->Report( msg, RPT_SEVERITY_ACTION );
    }

    if( ( aNetlistComponent->GetProperties().count( "exclude_from_bom" ) > 0 )
            != ( ( aPcbFootprint->GetAttributes() & FP_EXCLUDE_FROM_BOM ) > 0 ) )
    {
        if( m_isDryRun )
        {
            if( aNetlistComponent->GetProperties().count( "exclude_from_bom" ) )
            {
                msg.Printf( _( "Add %s 'exclude from BOM' fabrication attribute." ),
                            aPcbFootprint->GetReference() );
            }
            else
            {
                msg.Printf( _( "Remove %s 'exclude from BOM' fabrication attribute." ),
                            aPcbFootprint->GetReference() );
            }
        }
        else
        {
            int attributes = aPcbFootprint->GetAttributes();

            if( aNetlistComponent->GetProperties().count( "exclude_from_bom" ) )
            {
                attributes |= FP_EXCLUDE_FROM_BOM;
                msg.Printf( _( "Added %s 'exclude from BOM' fabrication attribute." ),
                            aPcbFootprint->GetReference() );
            }
            else
            {
                attributes &= ~FP_EXCLUDE_FROM_BOM;
                msg.Printf( _( "Removed %s 'exclude from BOM' fabrication attribute." ),
                            aPcbFootprint->GetReference() );
            }

            changed = true;
            aPcbFootprint->SetAttributes( attributes );
        }

        m_reporter->Report( msg, RPT_SEVERITY_ACTION );
    }

    if( changed && copy )
        m_commit.Modified( aPcbFootprint, copy );
    else
        delete copy;

    return true;
}

References _, KIID_PATH::AsString(), FOOTPRINT::Clone(), copy, FP_EXCLUDE_FROM_BOM, FOOTPRINT::GetAttributes(), COMPONENT::GetKIIDs(), COMPONENT::GetPath(), FOOTPRINT::GetPath(), COMPONENT::GetProperties(), FOOTPRINT::GetProperties(), COMPONENT::GetReference(), FOOTPRINT::GetReference(), COMMIT::GetStatus(), COMPONENT::GetValue(), FOOTPRINT::GetValue(), m_commit, m_isDryRun, m_reporter, COMMIT::Modified(), REPORTER::Report(), RPT_SEVERITY_ACTION, FOOTPRINT::SetAttributes(), FOOTPRINT::SetPath(), FOOTPRINT::SetProperties(), FOOTPRINT::SetReference(), and FOOTPRINT::SetValue().

Referenced by UpdateNetlist().

UpdateNetlist()

bool BOARD_NETLIST_UPDATER::UpdateNetlist

(

NETLIST &

aNetlist

)

Update the board's components according to the new netlist.

See BOARD_NETLIST_UPDATER class description for the details of the process.

Parameters

aNetlist

the new netlist

Returns

true if process was completed successfullySet the reporter object.

Definition at line 902 of file board_netlist_updater.cpp.

{
    FOOTPRINT* lastPreexistingFootprint = nullptr;
    COMPONENT* component = nullptr;
    wxString   msg;

    m_errorCount = 0;
    m_warningCount = 0;
    m_newFootprintsCount = 0;

    std::map<COMPONENT*, FOOTPRINT*> footprintMap;

    if( !m_board->Footprints().empty() )
        lastPreexistingFootprint = m_board->Footprints().back();

    cacheCopperZoneConnections();

    // First mark all nets (except <no net>) as stale; we'll update those which are current
    // in the following two loops.
    //
    if( !m_isDryRun )
    {
        m_board->SetStatus( 0 );

        for( NETINFO_ITEM* net : m_board->GetNetInfo() )
            net->SetIsCurrent( net->GetNetCode() == 0 );
    }

    // Next go through the netlist updating all board footprints which have matching component
    // entries and adding new footprints for those that don't.
    //
    for( unsigned i = 0; i < aNetlist.GetCount(); i++ )
    {
        component = aNetlist.GetComponent( i );

        if( component->GetProperties().count( "exclude_from_board" ) )
            continue;

        msg.Printf( _( "Processing symbol '%s:%s'." ),
                    component->GetReference(),
                    component->GetFPID().Format().wx_str() );
        m_reporter->Report( msg, RPT_SEVERITY_INFO );

        int matchCount = 0;

        for( FOOTPRINT* footprint : m_board->Footprints() )
        {
            bool match = false;

            if( m_lookupByTimestamp )
            {
                for( auto& uuid : component->GetKIIDs() )
                {
                    KIID_PATH base = component->GetPath();
                    base.push_back( uuid );

                    if( footprint->GetPath() == base )
                    {
                        match = true;
                        break;
                    }
                }
            }
            else
                match = footprint->GetReference().CmpNoCase( component->GetReference() ) == 0;

            if( match )
            {
                FOOTPRINT* tmp = footprint;

                if( m_replaceFootprints && component->GetFPID() != footprint->GetFPID() )
                    tmp = replaceComponent( aNetlist, footprint, component );

                if( tmp )
                {
                    footprintMap[ component ] = tmp;

                    updateFootprintParameters( tmp, component );
                    updateComponentPadConnections( tmp, component );
                }

                matchCount++;
            }

            if( footprint == lastPreexistingFootprint )
            {
                // No sense going through the newly-created footprints: end of loop
                break;
            }
        }

        if( matchCount == 0 )
        {
            FOOTPRINT* footprint = addNewComponent( component );

            if( footprint )
            {
                footprintMap[ component ] = footprint;

                updateFootprintParameters( footprint, component );
                updateComponentPadConnections( footprint, component );
            }
        }
        else if( matchCount > 1 )
        {
            msg.Printf( _( "Multiple footprints found for \"%s\"." ),
                        component->GetReference() );
            m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        }
    }

    updateCopperZoneNets( aNetlist );

    // Finally go through the board footprints and update all those that *don't* have matching
    // component entries.
    //
    for( FOOTPRINT* footprint : m_board->Footprints() )
    {
        bool doDelete = m_deleteUnusedComponents;

        if( ( footprint->GetAttributes() & FP_BOARD_ONLY ) > 0 )
            doDelete = false;

        if( doDelete )
        {
            if( m_lookupByTimestamp )
                component = aNetlist.GetComponentByPath( footprint->GetPath() );
            else
                component = aNetlist.GetComponentByReference( footprint->GetReference() );

            if( component && component->GetProperties().count( "exclude_from_board" ) == 0 )
                doDelete = false;
        }

        if( doDelete && footprint->IsLocked() )
        {
            if( m_isDryRun )
            {
                msg.Printf( _( "Cannot remove unused footprint %s (locked)." ),
                            footprint->GetReference() );
            }
            else
            {
                msg.Printf( _( "Could not remove unused footprint %s (locked)." ),
                            footprint->GetReference() );
            }

            m_reporter->Report( msg, RPT_SEVERITY_WARNING );
            doDelete = false;
        }

        if( doDelete )
        {
            if( m_isDryRun )
            {
                msg.Printf( _( "Remove unused footprint %s." ), footprint->GetReference() );
            }
            else
            {
                m_commit.Remove( footprint );
                msg.Printf( _( "Removed unused footprint %s." ), footprint->GetReference() );
            }

            m_reporter->Report( msg, RPT_SEVERITY_ACTION );
        }
        else if( !m_isDryRun )
        {
            for( PAD* pad : footprint->Pads() )
            {
                if( pad->GetNet() )
                    pad->GetNet()->SetIsCurrent( true );
            }
        }
    }

    if( !m_isDryRun )
    {
        m_board->GetConnectivity()->Build( m_board );
        testConnectivity( aNetlist, footprintMap );

        // Now the connectivity data is rebuilt, we can delete single pads nets
        if( m_deleteSinglePadNets )
            deleteSinglePadNets();

        for( NETINFO_ITEM* net : m_board->GetNetInfo() )
        {
            if( !net->IsCurrent() )
            {
                msg.Printf( _( "Removed unused net %s." ), net->GetNetname() );
                m_reporter->Report( msg, RPT_SEVERITY_ACTION );
                m_commit.Removed( net );
            }
        }

        m_board->GetNetInfo().RemoveUnusedNets();
        m_commit.SetResolveNetConflicts();
        m_commit.Push( _( "Update netlist" ) );

        m_board->SynchronizeNetsAndNetClasses();
        m_frame->SaveProjectSettings();
    }
    else if( m_deleteSinglePadNets && !m_newFootprintsCount )
    {
        // We can delete single net pads in dry run mode only if no new footprints
        // are added, because these new footprints are not actually added to the board
        // and the current pad list is wrong in this case.
        deleteSinglePadNets();
    }

    if( m_isDryRun )
    {
        for( const std::pair<const wxString, NETINFO_ITEM*>& addedNet : m_addedNets )
            delete addedNet.second;

        m_addedNets.clear();
    }

    // Update the ratsnest
    m_reporter->ReportTail( wxT( "" ), RPT_SEVERITY_ACTION );
    m_reporter->ReportTail( wxT( "" ), RPT_SEVERITY_ACTION );

    msg.Printf( _( "Total warnings: %d, errors: %d." ), m_warningCount, m_errorCount );
    m_reporter->ReportTail( msg, RPT_SEVERITY_INFO );

    return true;
}

References _, addNewComponent(), cacheCopperZoneConnections(), deleteSinglePadNets(), BOARD::Footprints(), LIB_ID::Format(), FP_BOARD_ONLY, NETLIST::GetComponent(), NETLIST::GetComponentByPath(), NETLIST::GetComponentByReference(), BOARD::GetConnectivity(), NETLIST::GetCount(), COMPONENT::GetFPID(), COMPONENT::GetKIIDs(), BOARD::GetNetInfo(), COMPONENT::GetPath(), COMPONENT::GetProperties(), COMPONENT::GetReference(), m_addedNets, m_board, m_commit, m_deleteSinglePadNets, m_deleteUnusedComponents, m_errorCount, m_frame, m_isDryRun, m_lookupByTimestamp, m_newFootprintsCount, m_replaceFootprints, m_reporter, m_warningCount, pad, BOARD_COMMIT::Push(), COMMIT::Remove(), COMMIT::Removed(), NETINFO_LIST::RemoveUnusedNets(), replaceComponent(), REPORTER::Report(), REPORTER::ReportTail(), RPT_SEVERITY_ACTION, RPT_SEVERITY_ERROR, RPT_SEVERITY_INFO, RPT_SEVERITY_WARNING, PCB_EDIT_FRAME::SaveProjectSettings(), BOARD_COMMIT::SetResolveNetConflicts(), EDA_ITEM::SetStatus(), BOARD::SynchronizeNetsAndNetClasses(), testConnectivity(), updateComponentPadConnections(), updateCopperZoneNets(), updateFootprintParameters(), and UTF8::wx_str().

Referenced by PCB_EDIT_FRAME::KiwayMailIn().

Member Data Documentation

m_addedComponents

std::vector<FOOTPRINT*> BOARD_NETLIST_UPDATER::m_addedComponents

private

Definition at line 172 of file board_netlist_updater.h.

Referenced by addNewComponent(), and GetAddedComponents().

m_addedNets

std::map<wxString, NETINFO_ITEM*> BOARD_NETLIST_UPDATER::m_addedNets

private

Definition at line 173 of file board_netlist_updater.h.

Referenced by updateComponentPadConnections(), updateCopperZoneNets(), and UpdateNetlist().

m_board

BOARD* BOARD_NETLIST_UPDATER::m_board

private

Definition at line 165 of file board_netlist_updater.h.

Referenced by addNewComponent(), cacheCopperZoneConnections(), deleteSinglePadNets(), estimateComponentInsertionPosition(), updateComponentPadConnections(), updateCopperZoneNets(), and UpdateNetlist().

m_commit

BOARD_COMMIT BOARD_NETLIST_UPDATER::m_commit

private

Definition at line 164 of file board_netlist_updater.h.

Referenced by addNewComponent(), replaceComponent(), updateComponentPadConnections(), updateCopperZoneNets(), updateFootprintParameters(), and UpdateNetlist().

m_deleteSinglePadNets

bool BOARD_NETLIST_UPDATER::m_deleteSinglePadNets

private

Definition at line 175 of file board_netlist_updater.h.

Referenced by BOARD_NETLIST_UPDATER(), SetDeleteSinglePadNets(), and UpdateNetlist().

m_deleteUnusedComponents

bool BOARD_NETLIST_UPDATER::m_deleteUnusedComponents

private

Definition at line 176 of file board_netlist_updater.h.

Referenced by BOARD_NETLIST_UPDATER(), SetDeleteUnusedComponents(), and UpdateNetlist().

m_errorCount

int BOARD_NETLIST_UPDATER::m_errorCount

private

Definition at line 183 of file board_netlist_updater.h.

Referenced by addNewComponent(), BOARD_NETLIST_UPDATER(), replaceComponent(), testConnectivity(), and UpdateNetlist().

m_frame

PCB_EDIT_FRAME* BOARD_NETLIST_UPDATER::m_frame

private

Definition at line 163 of file board_netlist_updater.h.

Referenced by addNewComponent(), replaceComponent(), updateCopperZoneNets(), and UpdateNetlist().

m_isDryRun

bool BOARD_NETLIST_UPDATER::m_isDryRun

private

Definition at line 177 of file board_netlist_updater.h.

Referenced by addNewComponent(), BOARD_NETLIST_UPDATER(), deleteSinglePadNets(), getNetname(), getPinFunction(), replaceComponent(), SetIsDryRun(), updateComponentPadConnections(), updateCopperZoneNets(), updateFootprintParameters(), and UpdateNetlist().

m_lookupByTimestamp

bool BOARD_NETLIST_UPDATER::m_lookupByTimestamp

private

Definition at line 179 of file board_netlist_updater.h.

Referenced by BOARD_NETLIST_UPDATER(), SetLookupByTimestamp(), and UpdateNetlist().

m_newFootprintsCount

int BOARD_NETLIST_UPDATER::m_newFootprintsCount

private

Definition at line 184 of file board_netlist_updater.h.

Referenced by addNewComponent(), BOARD_NETLIST_UPDATER(), replaceComponent(), and UpdateNetlist().

m_oldToNewNets

std::map<wxString, wxString> BOARD_NETLIST_UPDATER::m_oldToNewNets

private

Definition at line 169 of file board_netlist_updater.h.

Referenced by updateComponentPadConnections(), and updateCopperZoneNets().

m_padNets

std::map<PAD*, wxString> BOARD_NETLIST_UPDATER::m_padNets

private

Definition at line 170 of file board_netlist_updater.h.

Referenced by cacheNetname(), and getNetname().

m_padPinFunctions

std::map<PAD*, wxString> BOARD_NETLIST_UPDATER::m_padPinFunctions

private

Definition at line 171 of file board_netlist_updater.h.

Referenced by cachePinFunction(), and getPinFunction().

m_replaceFootprints

bool BOARD_NETLIST_UPDATER::m_replaceFootprints

private

Definition at line 178 of file board_netlist_updater.h.

Referenced by BOARD_NETLIST_UPDATER(), SetReplaceFootprints(), and UpdateNetlist().

m_reporter

REPORTER* BOARD_NETLIST_UPDATER::m_reporter

private

Definition at line 166 of file board_netlist_updater.h.

Referenced by addNewComponent(), BOARD_NETLIST_UPDATER(), deleteSinglePadNets(), replaceComponent(), SetReporter(), testConnectivity(), updateComponentPadConnections(), updateCopperZoneNets(), updateFootprintParameters(), and UpdateNetlist().

m_warnForNoNetPads

bool BOARD_NETLIST_UPDATER::m_warnForNoNetPads

private

Definition at line 180 of file board_netlist_updater.h.

Referenced by BOARD_NETLIST_UPDATER(), SetWarnPadNoNetInNetlist(), and updateComponentPadConnections().

m_warningCount

int BOARD_NETLIST_UPDATER::m_warningCount

private

Definition at line 182 of file board_netlist_updater.h.

Referenced by BOARD_NETLIST_UPDATER(), updateCopperZoneNets(), and UpdateNetlist().

m_zoneConnectionsCache

std::map<ZONE*, std::vector<PAD*> > BOARD_NETLIST_UPDATER::m_zoneConnectionsCache

private

Definition at line 168 of file board_netlist_updater.h.

Referenced by cacheCopperZoneConnections(), and updateCopperZoneNets().

---

The documentation for this class was generated from the following files:

• board_netlist_updater.h
• board_netlist_updater.cpp