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
 * @author Jon Evans <jon@craftyjon.com>
 *
 * 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 )
    {}

    ~CONNECTION_SUBGRAPH() = default;

    bool ResolveDrivers( bool aCreateMarkers = false );

    wxString GetNetName() const;

    std::vector<SCH_ITEM*> GetBusLabels() const;

    const wxString& GetNameForDriver( SCH_ITEM* aItem );

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

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

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

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

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

    void buildConnectionGraph();

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

};

#endif