Event::RelTable< T1, T2 > Class Template Reference

#include <RelTable.h>

List of all members.

Public Member Functions
	RelTable ()
	RelTable (ObjectList< Relation< T1, T2 > > *rels)
void	init ()
	Initialize the internal pointer to an ObjectList of relations.
void	addDupRel (Relation< T1, T2 > *rel)
bool	addRelation (Relation< T1, T2 > *rel)
std::vector< Relation< T1, T2 > * >	getRelByFirst (const T1 *pobj) const
std::vector< Relation< T1, T2 > * >	getRelBySecond (const T2 *pobj) const
void	erase (Relation< T1, T2 > *rel)
void	changeFirst (Relation< T1, T2 > *rel, T1 *pobj)
void	changeSecond (Relation< T1, T2 > *rel, T2 *pobj)
unsigned long	size () const
	This method returns the number of relations in the table.
ObjectList< Relation< T1, T2 > > *	getAllRelations () const
	Returns the pointer to the collection of relations.
Private Member Functions
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)
Private Attributes
ObjectList< Relation< T1, T2 > > *	m_relations
	Pointer to a collection of relations.

---

Detailed Description

template<class T1, class T2>
class Event::RelTable< T1, T2 >

Definition at line 29 of file RelTable.h.

---

Constructor & Destructor Documentation

template<class T1, class T2>

Event::RelTable< T1, T2 >::RelTable

(

)

[inline]

Definition at line 33 of file RelTable.h.

{}

template<class T1, class T2>

RelTable::RelTable

(

ObjectList< Relation< T1, T2 > > *

rels

)

[inline]

Definition at line 124 of file RelTable.h.

References Event::RelTable< T1, T2 >::m_relations.

                                                                         {
    
    m_relations = rels;
    
  }

---

Member Function Documentation

template<class T1, class T2>

void RelTable::addDupRel

(

Relation< T1, T2 > *

rel

)

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)

Definition at line 131 of file RelTable.h.

References Event::RelTable< T1, T2 >::bindRelationFirst(), Event::RelTable< T1, T2 >::bindRelationSecond(), and Event::RelTable< T1, T2 >::m_relations.

                                                        {
    // 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::addRelation

(

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

Parameters:

rel

is a pointer to a relation between two objects

Returns:

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)

Definition at line 143 of file RelTable.h.

References Event::RelTable< T1, T2 >::bindRelationNoDup(), Event::RelTable< T1, T2 >::bindRelationSecond(), and Event::RelTable< T1, T2 >::m_relations.

Referenced by Event::RelTable< T1, T2 >::changeFirst(), Event::RelTable< T1, T2 >::changeSecond(), and MucRecTrkExt::execute().

                                                          {
    // 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>

void RelTable::bindRelationFirst

(

Relation< T1, T2 > *

rel

)

[inline, private]

Definition at line 272 of file RelTable.h.

References Event::Relation< T1, T2 >::getFirst(), Event::Relation< T1, T2 >::m_first, Event::RelTable< T1, T2 >::m_relations, Event::RelKey< T1, T2, T3 >::setPrev(), Event::RelKey< T1, T2, T3 >::setSame(), and subSeperate::temp.

Referenced by Event::RelTable< T1, T2 >::addDupRel().

                                                                       {
    
    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>

bool RelTable::bindRelationNoDup

(

Relation< T1, T2 > *

rel

)

[inline, private]

Definition at line 363 of file RelTable.h.

References eformat::write::copy(), Event::RelTable< T1, T2 >::findDup(), Event::Relation< T1, T2 >::getFirst(), Event::Relation< T1, T2 >::m_first, Event::Relation< T1, T2 >::m_infos, Event::RelTable< T1, T2 >::m_relations, Event::RelKey< T1, T2, T3 >::setPrev(), Event::RelKey< T1, T2, T3 >::setSame(), and subSeperate::temp.

Referenced by Event::RelTable< T1, T2 >::addRelation().

                                                                       {
    
    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>

void RelTable::bindRelationSecond

(

Relation< T1, T2 > *

rel

)

[inline, private]

Definition at line 310 of file RelTable.h.

References Event::Relation< T1, T2 >::getSecond(), Event::RelTable< T1, T2 >::m_relations, Event::Relation< T1, T2 >::m_second, Event::RelKey< T1, T2, T3 >::setPrev(), Event::RelKey< T1, T2, T3 >::setSame(), and subSeperate::temp.

Referenced by Event::RelTable< T1, T2 >::addDupRel(), and Event::RelTable< T1, T2 >::addRelation().

                                                                        {
    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>

void RelTable::changeFirst	(	Relation< T1, T2 > *	rel,
		T1 *	pobj
	)

This method change the first data pointer of a given relation contained into the table.

Parameters:

	rel	it's a pointer to the relation to be modified
	pobj	is the new data value provided by the user

Definition at line 230 of file RelTable.h.

References Event::RelTable< T1, T2 >::addRelation(), Event::RelTable< T1, T2 >::m_relations, Event::RelTable< T1, T2 >::removeFirst(), Event::RelTable< T1, T2 >::removeSecond(), and Event::Relation< T1, T2 >::setFirst().

                                                                    {
    // 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::changeSecond	(	Relation< T1, T2 > *	rel,
		T2 *	pobj
	)

This method change the second data pointer of a given relation contained into the table.

Parameters:

	rel	it's a pointer to the relation to be modified
	pobj	is the new data value provided by the user

Definition at line 243 of file RelTable.h.

References Event::RelTable< T1, T2 >::addRelation(), Event::RelTable< T1, T2 >::m_relations, Event::RelTable< T1, T2 >::removeFirst(), Event::RelTable< T1, T2 >::removeSecond(), and Event::Relation< T1, T2 >::setSecond().

                                                                     {
    // 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>

void RelTable::erase

(

Relation< T1, T2 > *

rel

)

This method erase a particular relation from the table (keeping the integrity).

Parameters:

rel

it's a pointer to the relation to be erased

Definition at line 218 of file RelTable.h.

References Event::RelTable< T1, T2 >::m_relations, Event::RelTable< T1, T2 >::removeFirst(), and Event::RelTable< T1, T2 >::removeSecond().

                                                    {
    // 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>

Relation< T1, T2 > * RelTable::findDup	(	Relation< T1, T2 > *	rel1,
		Relation< T1, T2 > *	rel2
	)			[inline, private]

Definition at line 349 of file RelTable.h.

References Event::RelKey< T1, T2, T3 >::getSame(), Event::Relation< T1, T2 >::getSecond(), and Event::Relation< T1, T2 >::m_first.

Referenced by Event::RelTable< T1, T2 >::bindRelationNoDup().

    {
      while (rel1)
        {
          if (rel1->getSecond() == rel2->getSecond())
            return rel1;
          rel1 = rel1->m_first.getSame();
        }
      return rel1;
    }

template<class T1, class T2>

ObjectList< Relation< T1, T2 > > * RelTable::getAllRelations

(

)

const [inline]

Returns the pointer to the collection of relations.

Definition at line 263 of file RelTable.h.

References Event::RelTable< T1, T2 >::m_relations.

                                                                                 {
    
    return m_relations;
    
  }

template<class T1, class T2>

std::vector< Relation< T1, T2 > * > RelTable::getRelByFirst

(

const T1 *

pobj

)

const

This method search for all relations having obj in the first field.

Parameters:

obj

it's a pointer to the object given by the user

Returns:

A vector of pointers to the relations involving the given object.

Definition at line 163 of file RelTable.h.

References Event::RelTable< T1, T2 >::m_relations.

Referenced by MucRecTrkExt::execute().

                                                                                     {
    // 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::getRelBySecond

(

const T2 *

pobj

)

const

This method search for all relations having pobj in the second field.

Parameters:

pobj

it's a pointer to the object given by the user

Returns:

A vector of pointers to the relations involving the given object.

Definition at line 191 of file RelTable.h.

References Event::RelTable< T1, T2 >::m_relations.

                                                                                      {
    // 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 Event::RelTable< T1, T2 >::init

(

)

[inline]

Initialize the internal pointer to an ObjectList of relations.

Definition at line 38 of file RelTable.h.

References Event::RelTable< T1, T2 >::m_relations.

Referenced by MucRecTrkExt::execute().

{ m_relations = new ObjectList< Relation<T1,T2> >;}

template<class T1, class T2>

void RelTable::removeFirst

(

Relation< T1, T2 > *

rel

)

[inline, private]

Definition at line 414 of file RelTable.h.

References first, Event::RelKey< T1, T2, T3 >::getFirst(), Event::RelKey< T1, T2, T3 >::getPrev(), Event::RelKey< T1, T2, T3 >::getSame(), Event::Relation< T1, T2 >::m_first, next, EvtCyclic3::prev(), Event::RelKey< T1, T2, T3 >::setFirst(), Event::RelKey< T1, T2, T3 >::setPrev(), and Event::RelKey< T1, T2, T3 >::setSame().

Referenced by Event::RelTable< T1, T2 >::changeFirst(), Event::RelTable< T1, T2 >::changeSecond(), and Event::RelTable< T1, T2 >::erase().

                                                                 {

    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>

void RelTable::removeSecond

(

Relation< T1, T2 > *

rel

)

[inline, private]

Definition at line 439 of file RelTable.h.

References first, Event::RelKey< T1, T2, T3 >::getFirst(), Event::RelKey< T1, T2, T3 >::getPrev(), Event::RelKey< T1, T2, T3 >::getSame(), Event::Relation< T1, T2 >::m_second, next, EvtCyclic3::prev(), Event::RelKey< T1, T2, T3 >::setFirst(), Event::RelKey< T1, T2, T3 >::setPrev(), and Event::RelKey< T1, T2, T3 >::setSame().

Referenced by Event::RelTable< T1, T2 >::changeFirst(), Event::RelTable< T1, T2 >::changeSecond(), and Event::RelTable< T1, T2 >::erase().

                                                                  {

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

template<class T1, class T2>

unsigned long RelTable::size

(

)

const [inline]

This method returns the number of relations in the table.

Definition at line 256 of file RelTable.h.

References Event::RelTable< T1, T2 >::m_relations.

Referenced by MucRecTrkExt::execute().

                                                     {
    // Purpose: This method returns the total number of relations contained in the
    // collection
    return m_relations->size();
  }

---

Member Data Documentation

template<class T1, class T2>

ObjectList< Relation<T1,T2> >* Event::RelTable< T1, T2 >::m_relations [private]

Pointer to a collection of relations.

Definition at line 105 of file RelTable.h.

Referenced by Event::RelTable< T1, T2 >::addDupRel(), Event::RelTable< T1, T2 >::addRelation(), Event::RelTable< T1, T2 >::bindRelationFirst(), Event::RelTable< T1, T2 >::bindRelationNoDup(), Event::RelTable< T1, T2 >::bindRelationSecond(), Event::RelTable< T1, T2 >::changeFirst(), Event::RelTable< T1, T2 >::changeSecond(), Event::RelTable< T1, T2 >::erase(), Event::RelTable< T1, T2 >::getAllRelations(), Event::RelTable< T1, T2 >::getRelByFirst(), Event::RelTable< T1, T2 >::getRelBySecond(), Event::RelTable< T1, T2 >::init(), Event::RelTable< T1, T2 >::RelTable(), and Event::RelTable< T1, T2 >::size().

---