DirectedNodeNetwork.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler, Felix Metzner                       *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <vector>
#include <unordered_map>
 
#include <framework/logging/Logger.h>
 
#include <tracking/trackFindingVXD/segmentNetwork/DirectedNode.h>
 
 
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! Aborting 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! Aborting 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! Aborting 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;
 
    NodeID m_lastOuterNodeID;
 
    NodeID m_lastInnerNodeID;
 
    bool m_isFinalized;
 
    std::vector<Node*> m_nodes;
 
    std::vector<Node*> m_outerEnds;
 
    std::vector<Node*> m_innerEnds;
  };
}