DirectedNode.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 <vector>
 
namespace Belle2 {
  template<typename EntryType, typename MetaInfoType>
  class DirectedNode {
    template<typename AnyType, typename AnyOtherType> friend class DirectedNodeNetwork;
 
  protected:
    explicit DirectedNode(EntryType& entry) :
      m_entry(entry), m_metaInfo(MetaInfoType()), m_family(-1)
    {
      // Reserve some space for the vectors, TODO: can still be fine-tuned
      m_innerNodes.reserve(10);
      m_outerNodes.reserve(10);
    }
 
    DirectedNode(const DirectedNode& node) = delete;
 
    DirectedNode& operator=(const DirectedNode& node) = delete;
 
 
    void addInnerNode(DirectedNode<EntryType, MetaInfoType>& newNode)
    {
      m_innerNodes.push_back(&newNode);
    }
 
 
    void addOuterNode(DirectedNode<EntryType, MetaInfoType>& newNode)
    {
      m_outerNodes.push_back(&newNode);
    }
 
 
  public:
    bool operator == (const DirectedNode& b) const { return (m_entry == b.getConstEntry()); }
 
    bool operator != (const DirectedNode& b) const { return !(m_entry == b.getConstEntry()); }
 
    bool operator == (const EntryType& b) const { return (m_entry == b); }
 
    bool operator != (const EntryType& b) const { return !(m_entry == b); }
 
 
 
    std::vector<DirectedNode<EntryType, MetaInfoType>*>& getInnerNodes() { return m_innerNodes; }
 
    std::vector<DirectedNode<EntryType, MetaInfoType>*>& getOuterNodes() { return m_outerNodes; }
 
    EntryType& getEntry() { return m_entry; }
 
    const EntryType& getConstEntry() const { return m_entry; }
 
    DirectedNode<EntryType, MetaInfoType>* getPtr() { return this; }
 
    MetaInfoType& getMetaInfo() { return m_metaInfo; }
 
    short getFamily() const { return m_family; }
 
    void setFamily(short family) { m_family = family; }
 
 
    EntryType& m_entry;
 
    std::vector<DirectedNode<EntryType, MetaInfoType>*> m_innerNodes;
 
    std::vector<DirectedNode<EntryType, MetaInfoType>*> m_outerNodes;
 
    MetaInfoType m_metaInfo;
 
    short m_family;
  };
 
 
  template <class EntryType, class MetaInfoType>
  bool operator == (const EntryType& a, const DirectedNode<EntryType, MetaInfoType>& b)
  {
    return (a == b.getConstEntry());
  }
}