DirectedNodeNetwork.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <framework/logging/Logger.h>
 
#include <tracking/trackFindingVXD/segmentNetwork/DirectedNode.h>
 
#include <algorithm>
#include <cstdint>
#include <unordered_map>
#include <vector>
 
namespace Belle2 {
  template<typename EntryType, typename MetaInfoType>
  class DirectedNodeNetwork {
  protected:
    using Node = DirectedNode<EntryType, MetaInfoType>;
    using NodeID = std::int64_t;
 
  public:
    DirectedNodeNetwork() :
      m_lastOuterNodeID(),
      m_lastInnerNodeID(),
      m_isFinalized(false)
    {
      m_nodeMap.reserve(40000);
      m_nodes.reserve(40000);
    }
 

    ~DirectedNodeNetwork()
    {
      for (auto nodePointer : m_nodeMap) {
        delete nodePointer.second;
      }
      m_nodeMap.clear();
    }
 

    bool addNode(NodeID nodeID, EntryType& newEntry)
    {
      if (m_nodeMap.count(nodeID) == 0) {
        // cppcheck-suppress stlFindInsert
        m_nodeMap.emplace(nodeID, new Node(newEntry));
        m_isFinalized = false;
        return true;
      }
      return false;
    }
 

    bool addInnerToLastOuterNode(NodeID innerNodeID)
    {
      // check if entry does not exist, constructed with ID=-1
      if (m_lastOuterNodeID < 0) {
        B2WARNING("Last OuterNode is not yet in this network! CurrentNetworkSize is: " << size());
        return false;
      }
      // check if entries are identical (catch loops):
      if (m_lastOuterNodeID == innerNodeID) {
        B2WARNING("LastOuterNode and innerEntry are identical! Skipping linking-process");
        return false;
      }
 
      if (linkNodes(m_lastOuterNodeID, innerNodeID)) {
        return true;
      }
      B2WARNING("Last OuterNode and innerEntry were already in the network and were already connected."
                "This is a sign for unintended behavior!");
      return false;
    }
 

    bool addOuterToLastInnerNode(NodeID outerNodeID)
    {
      // check if entry does not exist, constructed with ID=-1
      if (m_lastInnerNodeID < 0) {
        B2WARNING("Last InnerNode is not yet in this network! CurrentNetworkSize is: " << size());
        return false;
      }
      // check if entries are identical (catch loops):
      if (outerNodeID == m_lastInnerNodeID) {
        B2WARNING("OuterEntry and lastInnerNode are identical! Skipping linking-process");
        return false;
      }
 
      if (linkNodes(outerNodeID, m_lastInnerNodeID)) {
        return true;
      }
 
      B2WARNING("Last InnerNode and outerEntry were already in the network and were already connected."
                "This is a sign for unintended behavior!");
      return false;
    }
 

    bool linkNodes(NodeID outerNodeID, NodeID innerNodeID)
    {
      m_isFinalized = false;
      // check if entries are identical (catch loops):
      if (outerNodeID == innerNodeID) {
        B2WARNING("OuterNodeID and innerNodeID are identical! Skipping linking-process");
        return false;
      }
      if (m_nodeMap.count(innerNodeID) == 0 or m_nodeMap.count(outerNodeID) == 0) {
        B2WARNING("Trying to link Nodes that are not present yet");
        return false;
      }
 
      m_lastOuterNodeID = outerNodeID;
      m_lastInnerNodeID = innerNodeID;
 
      return createLink(*(m_nodeMap[outerNodeID]), *(m_nodeMap[innerNodeID]));
    }
 

    inline bool isNodeInNetwork(const NodeID nodeID) const
    {
      return m_nodeMap.count(nodeID);
    }
 

    void clear()
    {
      m_nodes.clear();
      // Clearing the unordered_map is important as the following modules will process the event
      // if it still contains entries.
      for (auto nodePointer : m_nodeMap) {
        delete nodePointer.second;
      }
      m_nodeMap.clear();
    }
 


    std::vector<Node*> getOuterEnds()
    {
      if (!m_isFinalized) finalize();
      return m_outerEnds;
    }
 

    std::vector<Node*> getInnerEnds()
    {
      if (!m_isFinalized) finalize();
      return m_innerEnds;
    }
 

    Node* getNode(NodeID toBeFound)
    {
      if (m_nodeMap.count(toBeFound)) return m_nodeMap.at(toBeFound);
      else return nullptr;
    }

    std::vector<Node* >& getNodes()
    {
      if (!m_isFinalized) finalize();
      return m_nodes;
    }
 

    typename std::vector<Node* >::iterator begin()
    {
      if (!m_isFinalized) finalize();
      return m_nodes.begin();
    }
 

    typename std::vector<Node* >::iterator end()
    {
      if (!m_isFinalized) finalize();
      return m_nodes.end();
    }
 

    inline unsigned int size() const { return m_nodeMap.size(); }
 
 
  protected:
    static bool createLink(Node& outerNode, Node& innerNode)
    {
      // not successful if one of them was already added to the other one:
      if (std::find(outerNode.getInnerNodes().begin(), outerNode.getInnerNodes().end(), &innerNode) != outerNode.getInnerNodes().end()) {
        return false;
      }
      if (std::find(innerNode.getOuterNodes().begin(), innerNode.getOuterNodes().end(), &outerNode) != innerNode.getOuterNodes().end()) {
        return false;
      }
 
      outerNode.addInnerNode(innerNode);
      innerNode.addOuterNode(outerNode);
      return true;
    }

    void finalize()
    {
      if (m_isFinalized) return;
      m_nodes.clear();
      m_nodes.reserve(m_nodeMap.size());
      m_innerEnds.clear();
      m_outerEnds.clear();
      for (const auto& item : m_nodeMap) {
        m_nodes.push_back(item.second);
        if (item.second->getInnerNodes().empty()) m_innerEnds.push_back(item.second);
        if (item.second->getOuterNodes().empty()) m_outerEnds.push_back(item.second);
      }
      m_isFinalized = true;
    }

    std::unordered_map<NodeID, Node*> m_nodeMap;

    std::vector<Node*> m_nodes;

    std::vector<Node*> m_outerEnds;

    std::vector<Node*> m_innerEnds;

    NodeID m_lastOuterNodeID;

    NodeID m_lastInnerNodeID;

    bool m_isFinalized;
 
  };

}