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 wxString GetNameForDriver( 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;

 std::unordered_map<SCH_ITEM*, wxString> m_driver_name_cache;

 SCH_ITEM* m_first_driver;

 SCH_ITEM* m_second_driver;
};

typedef std::pair<wxString, int> NET_NAME_CODE;

typedef std::map<NET_NAME_CODE, 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 );

private:
 void updateItemConnectivity( const SCH_SHEET_PATH& aSheet,
 const std::vector<SCH_ITEM*>& aItemList );

 void buildConnectionGraph();

 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 );

 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 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();

public:
 // TODO(JE) Remove this when pressure valve is removed
 static bool m_allowRealTime;

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::map<wxString, int> m_net_name_to_code_map;

 std::map<wxString, int> m_bus_name_to_code_map;

 std::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::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