connection_graph.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018 CERN
 * Copyright (C) 2021 KiCad Developers, see AUTHORS.txt for contributors.
 * @author Jon Evans <[email protected]>
 *
 * 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 2
 * 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/>.
 */
 
#ifndef _CONNECTION_GRAPH_H
#define _CONNECTION_GRAPH_H
 
#include <mutex>
#include <vector>
 
#include <erc_settings.h>
#include <sch_connection.h>
#include <sch_item.h>
 
 
#ifdef DEBUG
// Uncomment this line to enable connectivity debugging features
// #define CONNECTIVITY_DEBUG
#endif
 
 
class CONNECTION_GRAPH;
class SCHEMATIC;
class SCH_EDIT_FRAME;
class SCH_HIERLABEL;
class SCH_PIN;
class SCH_SHEET_PIN;
 
 
class CONNECTION_SUBGRAPH
{
public:
 enum class PRIORITY
 {
 INVALID = -1,
 NONE = 0,
 PIN,
 SHEET_PIN,
 HIER_LABEL,
 LOCAL_LABEL,
 POWER_PIN,
 GLOBAL
 };
 
 explicit CONNECTION_SUBGRAPH( CONNECTION_GRAPH* aGraph ) :
 m_graph( aGraph ),
 m_dirty( false ),
 m_absorbed( false ),
 m_absorbed_by( nullptr ),
 m_code( -1 ),
 m_multiple_drivers( false ),
 m_strong_driver( false ),
 m_local_driver( false ),
 m_no_connect( nullptr ),
 m_bus_entry( nullptr ),
 m_driver( nullptr ),
 m_driver_connection( nullptr ),
 m_hier_parent( nullptr ),
 m_first_driver( nullptr ),
 m_second_driver( nullptr )
 {}
 
 ~CONNECTION_SUBGRAPH() = default;
 
 bool ResolveDrivers( bool aCheckMultipleDrivers = false );
 
 wxString GetNetName() const;
 
 std::vector<SCH_ITEM*> GetBusLabels() const;
 
 const wxString& GetNameForDriver( SCH_ITEM* aItem ) const;
 
 const wxString GetNetclassForDriver( SCH_ITEM* aItem ) const;
 
 void Absorb( CONNECTION_SUBGRAPH* aOther );
 
 void AddItem( SCH_ITEM* aItem );
 
 void UpdateItemConnections();
 
 static PRIORITY GetDriverPriority( SCH_ITEM* aDriver );
 
 PRIORITY GetDriverPriority()
 {
 if( m_driver )
 return GetDriverPriority( m_driver );
 else
 return PRIORITY::NONE;
 }
 
private:
 wxString driverName( SCH_ITEM* aItem ) const;
 
public:
 CONNECTION_GRAPH* m_graph;
 
 bool m_dirty;
 
 bool m_absorbed;
 
 CONNECTION_SUBGRAPH* m_absorbed_by;
 
 long m_code;
 
 bool m_multiple_drivers;
 
 bool m_strong_driver;
 
 bool m_local_driver;
 
 SCH_ITEM* m_no_connect;
 
 SCH_ITEM* m_bus_entry;
 
 std::vector<SCH_ITEM*> m_items;
 
 std::vector<SCH_ITEM*> m_drivers;
 
 SCH_ITEM* m_driver;
 
 SCH_SHEET_PATH m_sheet;
 
 SCH_CONNECTION* m_driver_connection;
 
 std::unordered_map< std::shared_ptr<SCH_CONNECTION>,
 std::unordered_set<CONNECTION_SUBGRAPH*> > m_bus_neighbors;
 
 std::unordered_map< std::shared_ptr<SCH_CONNECTION>,
 std::unordered_set<CONNECTION_SUBGRAPH*> > m_bus_parents;
 
 // Cache for lookup of any hierarchical (sheet) pins on this subgraph (for referring down)
 std::vector<SCH_SHEET_PIN*> m_hier_pins;
 
 // Cache for lookup of any hierarchical ports on this subgraph (for referring up)
 std::vector<SCH_HIERLABEL*> m_hier_ports;
 
 // If not null, this indicates the subgraph on a higher level sheet that is linked to this one
 CONNECTION_SUBGRAPH* m_hier_parent;
 
 mutable std::unordered_map<SCH_ITEM*, wxString> m_driver_name_cache;
 
 SCH_ITEM* m_first_driver;
 
 SCH_ITEM* m_second_driver;
};
 
struct NET_NAME_CODE_CACHE_KEY
{
 wxString Name;
 int Netcode;
 
 bool operator==(const NET_NAME_CODE_CACHE_KEY& other) const
 {
 return Name == other.Name && Netcode == other.Netcode;
 }
};
 
namespace std
{
 template <>
 struct hash<NET_NAME_CODE_CACHE_KEY>
 {
 std::size_t operator()( const NET_NAME_CODE_CACHE_KEY& k ) const
 {
 const std::size_t prime = 19937;
 
 return hash<wxString>()( k.Name ) ^ ( hash<int>()( k.Netcode ) * prime );
 }
 };
}
 
typedef std::unordered_map<NET_NAME_CODE_CACHE_KEY, std::vector<CONNECTION_SUBGRAPH*>> NET_MAP;
 
class CONNECTION_GRAPH
{
public:
 CONNECTION_GRAPH( SCHEMATIC* aSchematic = nullptr ) :
 m_last_net_code( 1 ),
 m_last_bus_code( 1 ),
 m_last_subgraph_code( 1 ),
 m_schematic( aSchematic )
 {}
 
 ~CONNECTION_GRAPH()
 {
 Reset();
 }
 
 void Reset();
 
 void SetSchematic( SCHEMATIC* aSchematic )
 {
 m_schematic = aSchematic;
 }
 
 void Recalculate( const SCH_SHEET_LIST& aSheetList, bool aUnconditional = false,
 std::function<void( SCH_ITEM* )>* aChangedItemHandler = nullptr );
 
 std::shared_ptr<BUS_ALIAS> GetBusAlias( const wxString& aName );
 
 std::vector<const CONNECTION_SUBGRAPH*> GetBusesNeedingMigration();
 
 int RunERC();
 
 const NET_MAP& GetNetMap() const { return m_net_code_to_subgraphs_map; }
 
 CONNECTION_SUBGRAPH* FindSubgraphByName( const wxString& aNetName,
  const SCH_SHEET_PATH& aPath );
 
 CONNECTION_SUBGRAPH* FindFirstSubgraphByName( const wxString& aNetName );
 
 CONNECTION_SUBGRAPH* GetSubgraphForItem( SCH_ITEM* aItem );
 
 wxString GetResolvedSubgraphName( const CONNECTION_SUBGRAPH* aSubGraph ) const;
 
private:
 void updateItemConnectivity( const SCH_SHEET_PATH& aSheet,
 const std::vector<SCH_ITEM*>& aItemList );
 
 void buildConnectionGraph( std::function<void( SCH_ITEM* )>* aChangedItemHandler );
 
 void buildItemSubGraphs();
 
 void resolveAllDrivers();
 
 void collectAllDriverValues();
 
 void generateInvisiblePinSubGraphs();
 
 void processSubGraphs();
 
 int assignNewNetCode( SCH_CONNECTION& aConnection );
 
 void assignNetCodesToBus( SCH_CONNECTION* aConnection );
 
 void propagateToNeighbors( CONNECTION_SUBGRAPH* aSubgraph, bool aForce );
 
 static SCH_CONNECTION* matchBusMember( SCH_CONNECTION* aBusConnection,
 SCH_CONNECTION* aSearch );
 
 std::shared_ptr<SCH_CONNECTION> getDefaultConnection( SCH_ITEM* aItem,
 CONNECTION_SUBGRAPH* aSubgraph );
 
 void recacheSubgraphName( CONNECTION_SUBGRAPH* aSubgraph, const wxString& aOldName );
 
 bool ercCheckMultipleDrivers( const CONNECTION_SUBGRAPH* aSubgraph );
 
 bool ercCheckNetclassConflicts( const std::vector<CONNECTION_SUBGRAPH*>& subgraphs );
 
 bool ercCheckBusToNetConflicts( const CONNECTION_SUBGRAPH* aSubgraph );
 
 bool ercCheckBusToBusConflicts( const CONNECTION_SUBGRAPH* aSubgraph );
 
 bool ercCheckBusToBusEntryConflicts( const CONNECTION_SUBGRAPH* aSubgraph );
 
 bool ercCheckNoConnects( const CONNECTION_SUBGRAPH* aSubgraph );
 
 bool ercCheckFloatingWires( const CONNECTION_SUBGRAPH* aSubgraph );
 
 bool ercCheckLabels( const CONNECTION_SUBGRAPH* aSubgraph );
 
 int ercCheckHierSheets();
 
 size_t hasPins( const CONNECTION_SUBGRAPH* aLocSubgraph );
 
 
private:
 // All the sheets in the schematic (as long as we don't have partial updates)
 SCH_SHEET_LIST m_sheetList;
 
 // All connectable items in the schematic
 std::vector<SCH_ITEM*> m_items;
 
 // The owner of all CONNECTION_SUBGRAPH objects
 std::vector<CONNECTION_SUBGRAPH*> m_subgraphs;
 
 // Cache of a subset of m_subgraphs
 std::vector<CONNECTION_SUBGRAPH*> m_driver_subgraphs;
 
 // Cache to lookup subgraphs in m_driver_subgraphs by sheet path
 std::unordered_map<SCH_SHEET_PATH, std::vector<CONNECTION_SUBGRAPH*>> m_sheet_to_subgraphs_map;
 
 std::vector<std::pair<SCH_SHEET_PATH, SCH_PIN*>> m_invisible_power_pins;
 
 std::unordered_map<wxString, std::shared_ptr<BUS_ALIAS>> m_bus_alias_cache;
 
 std::unordered_map<wxString, int> m_net_name_to_code_map;
 
 std::unordered_map<wxString, int> m_bus_name_to_code_map;
 
 std::unordered_map<wxString, std::vector<const CONNECTION_SUBGRAPH*>> m_global_label_cache;
 
 std::map< std::pair<SCH_SHEET_PATH, wxString>,
 std::vector<const CONNECTION_SUBGRAPH*> > m_local_label_cache;
 
 std::unordered_map<wxString, std::vector<CONNECTION_SUBGRAPH*>> m_net_name_to_subgraphs_map;
 
 std::unordered_map<SCH_ITEM*, CONNECTION_SUBGRAPH*> m_item_to_subgraph_map;
 
 NET_MAP m_net_code_to_subgraphs_map;
 
 int m_last_net_code;
 
 int m_last_bus_code;
 
 int m_last_subgraph_code;
 
 SCHEMATIC* m_schematic; 
};
 
#endif