Event/RelTable/include/RelTable/RelTable.h

Go to the documentation of this file.

 
#ifndef RELTABLE_H
#define RELTABLE_H
 
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/SmartRef.h"
#include "Relation.h"
#include <algorithm>
#include <iterator>
#include <vector>
 
/**
 * @class RelTable
 *
 * @brief This class is used to wrap a collection of Relations.
 *
 * The RelTable class wraps a list (a Gaudi ObjectList) of Relations. It
 * lets the user search for all object related to a given one. The search can be
 * done with respect to an object of the first or the second field of the
 * relations. The user can also modify or delete relations.
 *
 */
 
namespace Event {
 
  template <class T1, class T2> class RelTable {
 
  public:
    RelTable() {}
    RelTable( ObjectList<Relation<T1, T2>>* rels );
 
    /// Initialize the internal pointer to an ObjectList of relations
    void init() { m_relations = new ObjectList<Relation<T1, T2>>; }
 
    /**
     * The following method add a new Relation to the table, even if there is
     * already a relation with the same two objects (they could have different
     * infos vector)
     */
    void addDupRel( Relation<T1, T2>* rel );
 
    /**
     * The following method add a Relation to the table if it doesn't contain
     * a relation between the same two objects, otherwise it appends the info
     * vector to the exsisting relation
     * @param rel is a pointer to a relation between two objects
     * @return true if the relation has been added and false if it is a duplicate
     * and has not been added (in this case the user has to delete it)
     */
    bool addRelation( Relation<T1, T2>* rel );
 
    /**
     * This method search for all relations having obj in the first
     * field.
     * @param obj it's a pointer to the object given by the user
     * @return A vector of pointers to the relations involving the given object.
     */
    std::vector<Relation<T1, T2>*> getRelByFirst( const T1* pobj ) const;
 
    /**
     * This method search for all relations having pobj in the second
     * field.
     * @param pobj it's a pointer to the object given by the user
     * @return A vector of pointers to the relations involving the given object.
     */
    std::vector<Relation<T1, T2>*> getRelBySecond( const T2* pobj ) const;
 
    /**
     * This method erase a particular relation from the table (keeping the
     * integrity).
     * @param rel it's a pointer to the relation to be erased
     */
    void erase( Relation<T1, T2>* rel );
 
    /**
     * This method change the first data pointer of a given relation contained
     * into the table.
     * @param rel it's a pointer to the relation to be modified
     * @param pobj is the new data value provided by the user
     */
    void changeFirst( Relation<T1, T2>* rel, T1* pobj );
 
    /**
     * This method change the second data pointer of a given relation contained
     * into the table.
     * @param rel it's a pointer to the relation to be modified
     * @param pobj is the new data value provided by the user
     */
    void changeSecond( Relation<T1, T2>* rel, T2* pobj );
 
    /// This method returns the number of relations in the table
    unsigned long size() const;
 
    /// Returns the pointer to the collection of relations.
    ObjectList<Relation<T1, T2>>* getAllRelations() const;
 
  private:
    /// Pointer to a collection of relations
    ObjectList<Relation<T1, T2>>* m_relations;
 
    void bindRelationFirst( Relation<T1, T2>* rel );
    void bindRelationSecond( Relation<T1, T2>* rel );
 
    void removeFirst( Relation<T1, T2>* rel );
    void removeSecond( Relation<T1, T2>* rel );
 
    Relation<T1, T2>* findDup( Relation<T1, T2>* rel1, Relation<T1, T2>* rel2 );
    bool              bindRelationNoDup( Relation<T1, T2>* rel );
  };
 
  template <class T1, class T2>
  inline RelTable<T1, T2>::RelTable( ObjectList<Relation<T1, T2>>* rels ) {
 
    m_relations = rels;
  }
 
  template <class T1, class T2> void RelTable<T1, T2>::addDupRel( Relation<T1, T2>* rel ) {
    // Purpose and Method:  This routine add a new relation to the collection, even
    // if there is a already a relation between the same two objects
    // Inputs:  rel is a pointer to the relation to be added.
 
    bindRelationFirst( rel );
    bindRelationSecond( rel );
    m_relations->push_back( rel );
  }
 
  template <class T1, class T2> bool RelTable<T1, T2>::addRelation( Relation<T1, T2>* rel ) {
    // Purpose and Method:  This routine add a relation to the table if it doesn't
    // contain a relation between the same two objects, otherwise it appends the info
    // vector to the exsisting relation
    // Inputs:  rel is a pointer to the relation to be added.
    // Outputs: a boolean value which is true if the realtion has been added to the
    //          table and false it it is a duplicate and thus has not been added.
    //          In the latter case the user has to delete the relation
 
    if ( bindRelationNoDup( rel ) )
    {
      bindRelationSecond( rel );
      m_relations->push_back( rel );
      return true;
    }
    return false;
  }
 
  template <class T1, class T2>
  std::vector<Relation<T1, T2>*> RelTable<T1, T2>::getRelByFirst( const T1* pobj ) const {
    // Purpose and Method: This routine finds all relations having pobj in the
    // first field.
    // Inputs: pobj is a pointer to the object to be searched in the first field
    // Outputs: A pointer to a vector of Relation* including pobj
 
    std::vector<Relation<T1, T2>*> rels;
    if ( !m_relations->size() ) return rels;
    SmartRef<Relation<T1, T2>> r = m_relations->front();
    while ( pobj != r->getFirst() && r->m_first.getFirst() ) { r = r->m_first.getFirst(); }
 
    if ( pobj == r->getFirst() )
    {
      rels.push_back( r );
      while ( r->m_first.getSame() )
      {
        rels.push_back( r->m_first.getSame() );
        r = r->m_first.getSame();
      }
    }
    return rels;
  }
 
  template <class T1, class T2>
  std::vector<Relation<T1, T2>*> RelTable<T1, T2>::getRelBySecond( const T2* pobj ) const {
    // Purpose and Method: This routine finds all relations having pobj in the
    // second field.
    // Inputs: pobj is a pointer to the object to be searched in the second field
    // Outputs: A pointer to a vector of Relation* including pobj
    std::vector<Relation<T1, T2>*> rels;
    if ( !m_relations->size() ) return rels;
    SmartRef<Relation<T1, T2>> r = m_relations->front();
    while ( pobj != r->getSecond() && r->m_second.getFirst() ) { r = r->m_second.getFirst(); }
 
    if ( pobj == r->getSecond() )
    {
      rels.push_back( r );
      while ( r->m_second.getSame() )
      {
        rels.push_back( r->m_second.getSame() );
        r = r->m_second.getSame();
      }
    }
    return rels;
  }
 
  template <class T1, class T2> void RelTable<T1, T2>::erase( Relation<T1, T2>* rel ) {
    // Purpose: This method remove the given relation from the table
 
    removeFirst( rel );
    removeSecond( rel );
 
    m_relations->remove( rel );
    delete rel;
  }
 
  template <class T1, class T2>
  void RelTable<T1, T2>::changeFirst( Relation<T1, T2>* rel, T1* pobj ) {
    // Purpose: This method change the first data pointer of a relation with the
    // one given by the user
 
    removeFirst( rel );
    removeSecond( rel );
    m_relations->remove( rel );
    rel->setFirst( pobj );
    addRelation( rel );
  }
 
  template <class T1, class T2>
  void RelTable<T1, T2>::changeSecond( Relation<T1, T2>* rel, T2* pobj ) {
    // Purpose: This method change the second data pointer of a relation with the
    // one given by the user
 
    removeFirst( rel );
    removeSecond( rel );
    m_relations->remove( rel );
    rel->setSecond( pobj );
    addRelation( rel );
  }
 
  template <class T1, class T2> inline unsigned long RelTable<T1, T2>::size() const {
    // Purpose: This method returns the total number of relations contained in the
    // collection
    return m_relations->size();
  }
 
  template <class T1, class T2>
  inline ObjectList<Relation<T1, T2>>* RelTable<T1, T2>::getAllRelations() const {
 
    return m_relations;
  }
 
  template <class T1, class T2>
  inline void RelTable<T1, T2>::bindRelationFirst( Relation<T1, T2>* rel ) {
 
    Relation<T1, T2>* temp;
 
    if ( m_relations->size() )
    {
      SmartRef<Relation<T1, T2>> r = m_relations->front();
      while ( ( r->getFirst() != rel->getFirst() ) )
      {
        if ( r->m_first.getFirst() ) { r = r->m_first.getFirst(); }
        else { break; }
      }
 
      if ( r->getFirst() != rel->getFirst() )
      {
        r->m_first.setFirst( rel );
        rel->m_first.setPrev( r );
      }
      else
      {
        temp = r->m_first.getSame();
        rel->m_first.setSame( temp );
        if ( temp ) temp->m_first.setPrev( rel );
        r->m_first.setSame( rel );
        rel->m_first.setPrev( r );
      }
    }
  }
 
  template <class T1, class T2>
  inline void RelTable<T1, T2>::bindRelationSecond( Relation<T1, T2>* rel ) {
    Relation<T1, T2>* temp;
 
    if ( m_relations->size() )
    {
      SmartRef<Relation<T1, T2>> r = m_relations->front();
 
      while ( ( r->getSecond() != rel->getSecond() ) )
      {
        if ( r->m_second.getFirst() ) { r = r->m_second.getFirst(); }
        else { break; }
      }
 
      if ( r->getSecond() != rel->getSecond() )
      {
        r->m_second.setFirst( rel );
        rel->m_second.setPrev( r );
      }
      else
      {
        temp = r->m_second.getSame();
        rel->m_second.setSame( temp );
        if ( temp ) temp->m_second.setPrev( rel );
        r->m_second.setSame( rel );
        rel->m_second.setPrev( r );
      }
    }
  }
 
  template <class T1, class T2>
  inline Relation<T1, T2>* RelTable<T1, T2>::findDup( Relation<T1, T2>* rel1,
                                                      Relation<T1, T2>* rel2 ) {
    while ( rel1 )
    {
      if ( rel1->getSecond() == rel2->getSecond() ) return rel1;
      rel1 = rel1->m_first.getSame();
    }
    return rel1;
  }
 
  template <class T1, class T2>
  inline bool RelTable<T1, T2>::bindRelationNoDup( Relation<T1, T2>* rel ) {
 
    Relation<T1, T2>* temp;
 
    if ( m_relations->size() )
    {
      SmartRef<Relation<T1, T2>> r = m_relations->front();
      while ( ( r->getFirst() != rel->getFirst() ) )
      {
        if ( r->m_first.getFirst() ) { r = r->m_first.getFirst(); }
        else { break; }
      }
 
      if ( r->getFirst() != rel->getFirst() )
      {
        r->m_first.setFirst( rel );
        rel->m_first.setPrev( r );
        return true;
      }
      else
      {
        temp = findDup( r, rel );
        if ( !temp )
        {
          temp = r->m_first.getSame();
          rel->m_first.setSame( temp );
          if ( temp ) temp->m_first.setPrev( rel );
          r->m_first.setSame( rel );
          rel->m_first.setPrev( r );
          return true;
        }
        else
        {
          std::copy( rel->m_infos.begin(), rel->m_infos.end(),
                     std::back_inserter( temp->m_infos ) );
          return false;
        }
      }
    }
    return true;
  }
 
  template <class T1, class T2>
  inline void RelTable<T1, T2>::removeFirst( Relation<T1, T2>* rel ) {
 
    Relation<T1, T2>*prev, *next, *first;
 
    prev = rel->m_first.getPrev();
    next = rel->m_first.getSame();
    if ( next ) next->m_first.setPrev( prev );
    if ( prev )
    {
      if ( prev->m_first.getFirst() ) prev->m_first.setFirst( next );
      else prev->m_first.setSame( next );
    }
    first = rel->m_first.getFirst();
    if ( first ) first->m_first.setPrev( next );
    rel->m_first.setPrev( 0 );
    rel->m_first.setSame( 0 );
    rel->m_first.setFirst( 0 );
  }
 
  template <class T1, class T2>
  inline void RelTable<T1, T2>::removeSecond( Relation<T1, T2>* rel ) {
 
    Relation<T1, T2>*prev, *next, *first;
 
    prev = rel->m_second.getPrev();
    next = rel->m_second.getSame();
    if ( next ) next->m_second.setPrev( prev );
    if ( prev )
    {
      if ( prev->m_second.getFirst() ) prev->m_second.setFirst( next );
      else prev->m_second.setSame( next );
    }
    first = rel->m_second.getFirst();
    if ( first ) first->m_second.setPrev( next );
    rel->m_second.setPrev( 0 );
    rel->m_second.setSame( 0 );
    rel->m_second.setFirst( 0 );
  }
 
} // namespace Event
 
#endif // RELTABLE_H