conn_netchain_manager.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The 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 <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <vector>
#include <unordered_map>
#include <sch_netchain.h>
#include <gal/color4d.h>
 
class CONNECTION_GRAPH;
class SCHEMATIC;
class SCH_ITEM;
class SCH_PIN;
class SCH_SCREEN;
class SCH_SHEET_PATH;
class SCH_SYMBOL;
class NET_SETTINGS;
void boost_test_inject_committed_net_chain( CONNECTION_GRAPH&, std::unique_ptr<SCH_NETCHAIN> );
 
namespace SCH_CONNECTIVITY
{
struct NETCHAIN_INPUT;

class NETCHAIN_MANAGER
{
public:
    explicit NETCHAIN_MANAGER( SCHEMATIC* aSchematic ) : m_schematic( aSchematic ) {}
 
    void Rebuild( const NETCHAIN_INPUT& aConnectivity,
                  const std::function<void( NETCHAIN_MANAGER& )>& aBeforePublish = {} );
    void ClearDerived();
    void RefreshTerminalReferences();
    void Merge( NETCHAIN_MANAGER& aOther );
    void SetSchematic( SCHEMATIC* aSchematic ) { m_schematic = aSchematic; }
 
    SCH_NETCHAIN* FindPotentialNetChainBetweenPins( SCH_PIN* aPinA, const SCH_SHEET_PATH& aPathA,
                                                   SCH_PIN* aPinB, const SCH_SHEET_PATH& aPathB );
    static wxString NetKeyForItem( const SCH_ITEM& aItem, const SCH_SHEET_PATH& aPath );

    std::map<SCH_SYMBOL*, SCH_SCREEN*> GetBridgeSymbols( const SCH_NETCHAIN& aChain,
                                                         const wxString& aNetKey ) const;
 
    SCH_NETCHAIN* GetNetChainForNet( const wxString& aNet );
    SCH_NETCHAIN* GetNetChainByName( const wxString& aName );
    struct TERMINAL_CHANGE
    {
        wxString chain;
        int endpoint = 0;
        KIID pin = niluuid;
        KIID_PATH sheet;
    };
 
    bool ReplaceNetChainTerminalPin( const TERMINAL_CHANGE& aChange );

    void SetNetChainNetClassOverrides( const std::map<wxString, wxString>& aOverrides )
    {
        m_netChainNetClassOverrides = aOverrides;
    }
 
    const std::map<wxString, wxString>& GetNetChainNetClassOverrides() const
    {
        return m_netChainNetClassOverrides;
    }
 
    struct CHAIN_TERMINAL_REF
    {
        wxString ref;
        wxString pin;
    };
    using CHAIN_TERMINAL_REFS = std::pair<CHAIN_TERMINAL_REF, CHAIN_TERMINAL_REF>;
 
    void SetNetChainTerminalRefOverrides( const std::map<wxString, CHAIN_TERMINAL_REFS>& aRefs )
    {
        m_netChainTerminalRefOverrides = aRefs;
    }
 
    const std::map<wxString, CHAIN_TERMINAL_REFS>& GetNetChainTerminalRefOverrides() const
    {
        return m_netChainTerminalRefOverrides;
    }
 
    void SetNetChainColorOverrides( const std::map<wxString, KIGFX::COLOR4D>& aOverrides )
    {
        m_netChainColorOverrides = aOverrides;
    }
 
    const std::map<wxString, KIGFX::COLOR4D>& GetNetChainColorOverrides() const
    {
        return m_netChainColorOverrides;
    }

    void SetNetChainMemberNetOverrides( const std::map<wxString, std::set<wxString>>& aOverrides )
    {
        m_netChainMemberNetOverrides = aOverrides;
    }
 
    const std::map<wxString, std::set<wxString>>& GetNetChainMemberNetOverrides() const
    {
        return m_netChainMemberNetOverrides;
    }

    const std::vector<std::unique_ptr<SCH_NETCHAIN>>& GetPotentialNetChains() const { return m_potentialNetChains; }

    SCH_NETCHAIN* CreateNetChainFromPotential( SCH_NETCHAIN* aPotential, const wxString& aName );

    SCH_NETCHAIN* CreateManualNetChain( const wxString& aName,
                                        const std::set<class SCH_SYMBOL*>& aSymbols,
                                        const std::set<wxString>& aNets,
                                        const KIID& aTerminalPinA, const KIID& aTerminalPinB,
                                        const wxString& aRefA, const wxString& aPinNumA,
                                        const wxString& aRefB, const wxString& aPinNumB );

    const std::vector<std::unique_ptr<SCH_NETCHAIN>>& GetCommittedNetChains() const { return m_committedNetChains; }

    void ApplyNetChainNetclasses();

    bool NetChainsBuilt() const { return m_netChainsBuilt; }

    bool DeleteCommittedNetChain( const wxString& aName );

    bool RenameCommittedNetChain( const wxString& aOld, const wxString& aNew );
 
private:
    void rebuild( const NETCHAIN_INPUT& aConnectivity );
    void setSymbolName( SCH_SYMBOL* aSymbol, const wxString& aName );
    bool resolveTerminals( SCH_NETCHAIN& aChain, const CHAIN_TERMINAL_REFS* aSavedRefs = nullptr );
    bool refreshTerminalReferences( SCH_NETCHAIN& aChain );
    void storeTerminalRefs( const SCH_NETCHAIN& aChain );

    wxString NetKeyForTerminal( const KIID& aPin, const KIID_PATH& aSheet ) const;

    void storeMemberNets( const wxString& aName, const std::set<wxString>& aNets );

    std::shared_ptr<NET_SETTINGS> liveNetSettings() const;
 
    friend class ::CONNECTION_GRAPH;
    friend void ::boost_test_inject_committed_net_chain( CONNECTION_GRAPH&,
                                                        std::unique_ptr<SCH_NETCHAIN> );

    static SCH_NETCHAIN* resolvePotentialChainByTerminals(
            const CHAIN_TERMINAL_REFS& aTermRefs,
            const std::map<std::pair<wxString, wxString>, wxString>& aRefPinToNet,
            const std::vector<std::unique_ptr<SCH_NETCHAIN>>& aPotentials,
            const wxString& aChainName );
 
    static SCH_NETCHAIN* findPotentialChain( const std::vector<std::unique_ptr<SCH_NETCHAIN>>& aPotentials,
                                             const wxString& aNetA, const wxString& aNetB );

    void rekeyOverrideMaps( const wxString& aOld, const wxString& aNew );

    void refreshCommittedChainPayload( SCH_NETCHAIN* aTarget, const std::set<wxString>& aNets,
                                       const std::set<class SCH_SYMBOL*>& aSymbols );

    void refreshCommittedChainFromPotential( SCH_NETCHAIN* aTarget, const SCH_NETCHAIN& aSource );
 
    // Bridge-graph helper types shared by RebuildNetChains() and FindNetChainPathsBetweenPins().
    // A bridge edge represents a 2-pin passthrough symbol that ties two distinct subgraph nets
    // together; the bridge graph is the adjacency built from the surviving (non-power-touching)
    // edges after the leaf-prune pass.
 
    struct SHEET_SYMBOLS;
 
    struct BRIDGE_EDGE
    {
        wxString             a;
        wxString             b;
        class SCH_SYMBOL*    sym;
        SCH_SCREEN*          screen;
    };
 
    struct BRIDGE_NEIGHBOR
    {
        wxString             other;
        class SCH_SYMBOL*    sym;
    };
 
    struct BRIDGE_GRAPH
    {
        std::map<wxString, std::vector<BRIDGE_NEIGHBOR>> adjacency;
        std::vector<BRIDGE_EDGE>                         edges;
    };

    BRIDGE_GRAPH buildBridgeAdjacency( const std::vector<SHEET_SYMBOLS>& aSheets );
 
    std::vector<std::unique_ptr<SCH_NETCHAIN>> m_committedNetChains;
    std::vector<std::unique_ptr<SCH_NETCHAIN>> m_potentialNetChains; 
    std::vector<BRIDGE_EDGE>                   m_bridgeEdges;        
    bool                                       m_netChainsBuilt = false;
    std::map<wxString, wxString>              m_netChainNetClassOverrides;
    std::map<wxString, KIGFX::COLOR4D>         m_netChainColorOverrides;
    std::map<wxString, CHAIN_TERMINAL_REFS>    m_netChainTerminalRefOverrides;
    std::map<wxString, std::set<wxString>>    m_netChainMemberNetOverrides;
 
    std::unordered_map<SCH_SYMBOL*, wxString>* m_pendingSymbolNames = nullptr;
    SCHEMATIC* m_schematic;
};
} // namespace SCH_CONNECTIVITY