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

    std::vector<DirectedNode<EntryType, MetaInfoType>*> m_innerNodes;

    std::vector<DirectedNode<EntryType, MetaInfoType>*> m_outerNodes;

    EntryType& m_entry;

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

}