OMK::DoubleList Class Reference

to lists, one being a subset of the other This class is used to store the list of object to activate at a given simulation step (active objects list), as well as the list of suspended objects which would be activated at that given simulation step if they weren't suspended (super list). More...

#include <OMKDoubleList.h>

Collaboration diagram for OMK::DoubleList:

[legend]List of all members.

Public Member Functions
	DoubleList ()
	contruct an empty list
bool	push_front (ReferenceObjectHandle *objectHandle)
	add a reference handle to the start of the super list.
bool	push_back (ReferenceObjectHandle *objectHandle)
	add a reference handle to the end of the super list.
bool	insert (ReferenceObjectHandle *objectHandle)
	insert a reference handle to the super list at a position that respects the ordering policy (at present defined by the < operator on referenceobjecthandles).
bool	remove (ReferenceObjectHandle *objectHandle)
	remove an object handle from the super list
bool	activate (ReferenceObjectHandle *M, DoubleListElement **elemExecPrec=0)
	pour ajouter un module à la liste des modules à compute
bool	suspend (ReferenceObjectHandle *M)
	pour supprimer un module de la liste des modules à compute
methods to iterate throught the super list
DoubleListElement *	superListBegin ()
	superListBegin
DoubleListElement *	superListNext (DoubleListElement *currentElement)
	get the element following the iterator passed as parameter in the super list
methods to iterate throught the active list
DoubleListElement *	begin ()
	begin
DoubleListElement *	next (DoubleListElement *pcour)
	get the element following the iterator passed as parameter in the active list
Protected Member Functions
DoubleListElement *	findInSuperList (ReferenceObjectHandle *p)
	Find an element in the super list.
DoubleListElement *	find (ReferenceObjectHandle *p)
	Find an element in the active list.
Protected Attributes
DoubleListElement *	_startOfSuperList
	first element in super list
DoubleListElement *	_lastOfSuperList
	last element in super list
DoubleListElement *	_start
	fisrt element in active liste
DoubleListElement *	_last
	last element in active list

---

Detailed Description

to lists, one being a subset of the other This class is used to store the list of object to activate at a given simulation step (active objects list), as well as the list of suspended objects which would be activated at that given simulation step if they weren't suspended (super list).

Author:

[David Margery]{mailto:David.Margery@irisa.fr}.

Version:

1.1

Definition at line 32 of file OMKDoubleList.h.

---

Constructor & Destructor Documentation

DoubleList::DoubleList

(

)

contruct an empty list

Definition at line 26 of file OMKDoubleList.cpp.

: _startOfSuperList( 0 ),
  _lastOfSuperList( 0 ),
  _start( 0 ),
  _last( 0 )
{
}

---

Member Function Documentation

bool DoubleList::push_front

(

ReferenceObjectHandle *

objectHandle

)

add a reference handle to the start of the super list.

A call to activate is needed to move the added reference handle to the active list.

Parameters:

objectHandle

the object handle of the object that could be activated

Returns:

true if call fails

Definition at line 35 of file OMKDoubleList.cpp.

References _lastOfSuperList, _startOfSuperList, OMK::DoubleListElement::nextInSuperList, and OMK::DoubleListElement::previousInSuperList.

                                                     {
 DoubleListElement * elem=new DoubleListElement(M);

 //1 Gestion de la liste complète
 //chainage dans le sens suivant;
 elem->nextInSuperList=_startOfSuperList;
 //chainage dans le sens précédent
 elem->previousInSuperList=NULL;
 if (_startOfSuperList!=NULL) {//la liste n'est pas vide
     _startOfSuperList->previousInSuperList=elem;
 }
 else {
   _lastOfSuperList=elem;
 }
 _startOfSuperList=elem;
 return false ;
}

bool DoubleList::push_back

(

ReferenceObjectHandle *

objectHandle

)

add a reference handle to the end of the super list.

A call to activate is needed to move the added reference handle to the active list.

Parameters:

objectHandle

the object handle of the object that could be activated

Returns:

true if call fails

Definition at line 53 of file OMKDoubleList.cpp.

References _lastOfSuperList, _startOfSuperList, OMK::DoubleListElement::nextInSuperList, and OMK::DoubleListElement::previousInSuperList.

                                                    {
 DoubleListElement * elem=new DoubleListElement(M);

 //1 Gestion de la liste complète
 //chainage dans le sens prec;
 elem->previousInSuperList=_lastOfSuperList;
 //chainage dans le sens suivant
 elem->nextInSuperList=NULL;
 if (_lastOfSuperList!=NULL) {//la liste n'est pas vide
     _lastOfSuperList->nextInSuperList=elem;
 }
 else {
   _startOfSuperList=elem;
 }
 _lastOfSuperList=elem;
 return false;
}

bool DoubleList::insert

(

ReferenceObjectHandle *

objectHandle

)

insert a reference handle to the super list at a position that respects the ordering policy (at present defined by the < operator on referenceobjecthandles).

A call to activate is needed to move the added reference handle to the active list.

Parameters:

objectHandle

the object handle of the object that could be activated

Returns:

true if call fails

Definition at line 71 of file OMKDoubleList.cpp.

References _last, _lastOfSuperList, _startOfSuperList, find(), findInSuperList(), OMK::DoubleListElement::listeElem, OMK::DoubleListElement::nextInSuperList, OMASSERTM, and OMK::DoubleListElement::previousInSuperList.

Referenced by OMK::FrameScheduler::addToScheduable().

{
   DoubleListElement * elem = new DoubleListElement(M);
   DoubleListElement * pcour = _startOfSuperList;
   DoubleListElement * prec = NULL;
   enum{ON_BOUCLE,FIN_LISTE,PLACE_TROUVEE} etatBoucle;
   etatBoucle=ON_BOUCLE;
   
   while(etatBoucle==ON_BOUCLE) 
      {
         if (pcour==NULL) 
            {
               etatBoucle=FIN_LISTE;
            }
         else 
            {
               if (*pcour->listeElem >= *M) 
                  {
                     etatBoucle=PLACE_TROUVEE;
                  }
               else 
                  {
                     prec=pcour;
                     pcour=pcour->nextInSuperList;
                  }
            }
      }
   /* ici on sait que 
    * si prec != NULL , *prec->listeElem < *M 
    * soit pcour == NULL ou *M <= *pcour->listeElem
    * Il faut donc refaire le chainage
    */
   elem->nextInSuperList=pcour;
   elem->previousInSuperList=prec;
   if (prec==NULL) {//insertion de l'élément au début
      if (pcour!=NULL) {//la liste n'est pas vide
         pcour->previousInSuperList=elem;
      }
      else {
           _lastOfSuperList=elem;
      } 
      _startOfSuperList=elem;
   }
   else {
      prec->nextInSuperList=elem;
      if (pcour==NULL) {//on ajoute à la fin
         _lastOfSuperList=elem;
      } 
      else {
         pcour->previousInSuperList=elem;
      }
   }
  //test intergrity of data
  if ( _lastOfSuperList != NULL ) 
     OMASSERTM( findInSuperList ( _lastOfSuperList->listeElem ) == _lastOfSuperList, "" ) ;
  if ( _last != NULL )
     OMASSERTM( find ( _last->listeElem) == _last, "" ) ;
   return false;
}

bool DoubleList::remove

(

ReferenceObjectHandle *

objectHandle

)

remove an object handle from the super list

Parameters:

objectHandle

the object handle of the object to remove

Returns:

true if operation fails

Definition at line 131 of file OMKDoubleList.cpp.

References _last, _lastOfSuperList, _start, _startOfSuperList, find(), findInSuperList(), OMK::DoubleListElement::listeElem, OMK::DoubleListElement::nextInActiveList, OMK::DoubleListElement::nextInSuperList, OMASSERTM, OMK::DoubleListElement::previousInActiveList, and OMK::DoubleListElement::previousInSuperList.

{
   DoubleListElement * elem = findInSuperList(M) ;
   if( elem != NULL ) 
      {//l'objet n'est pas déjà détruit
      if( ( elem->nextInActiveList != NULL ) ||
          ( elem->previousInActiveList != NULL ) ||
          ( _start == elem) ) 
         {
            //l'objet est encore dans la liste des objets à exécuter : on ne le détruit pas
            return true;
         }
      else 
         {
            DoubleListElement * prec=elem->previousInSuperList;
            DoubleListElement * suiv=elem->nextInSuperList;
            if(prec!=NULL) 
               {
                  prec->nextInSuperList=suiv;
               }
            else 
               {//l'élément détruit était en tete
                  _startOfSuperList=suiv;
               }
            if(suiv!=NULL) 
               {
                  suiv->previousInSuperList=prec;
               }
            else 
               {//l'élement détruit était en queue
                  _lastOfSuperList=prec;
               }
            delete elem;
         }
      }
  //test intergrity of data
  if ( _lastOfSuperList != NULL ) 
     OMASSERTM( findInSuperList ( _lastOfSuperList->listeElem ) == _lastOfSuperList, "" ) ;
  if ( _last != NULL )
     OMASSERTM( find ( _last->listeElem) == _last, "" ) ;
  return false;
}

bool DoubleList::activate	(	ReferenceObjectHandle *	M,
		DoubleListElement **	elemExecPrec = 0
	)

pour ajouter un module à la liste des modules à compute

Parameters:

	M	: la référence du module à ajouter
	elemExecPrec	: L'adresse d'un pointeur sur un pointeur d'élément. Si le resultat de la méthode est vrai, ce pointeur correspondra à l'élément de liste précedant dans la liste des exécutables. Si ce Pointeur est nul (valeur par défaut), l'information est ignorée.

Returns:

vrai si l'élément est dans la doubleListe.

Definition at line 175 of file OMKDoubleList.cpp.

References OMK::DoubleListElement::_isActive, _last, _lastOfSuperList, _start, _startOfSuperList, find(), findInSuperList(), OMK::DoubleListElement::listeElem, OMK::DoubleListElement::nextInActiveList, OMK::DoubleListElement::nextInSuperList, OMASSERTM, and OMK::DoubleListElement::previousInActiveList.

{
   bool result ;
   DoubleListElement * pcour = _startOfSuperList;
   DoubleListElement * resul = NULL;
   DoubleListElement * execSuiv = _start;
   DoubleListElement * execPrec = NULL;
   //on commence par chercher M dans la liste complète en gardant la trace du dernier élément qui appartient à la liste des exécutables.
   while((pcour!=NULL)&&(resul==NULL)) 
      {
         if( pcour->listeElem == M ) 
            {
               OMASSERTM( pcour->_isActive == false, "" ) ;
               resul = pcour;
            }
         else 
            {
               if( pcour->_isActive ) 
                  {//l'élément courant est dans la liste des exec
                     execPrec = pcour ;
                     execSuiv = pcour->nextInActiveList;
                  }
               pcour = pcour->nextInSuperList;
            }
      }
   //rendu ici, pcour contient un pointeur sur l'élément ou NULL si l'élément n'est pas dans la liste
   //execPrec, le précédant de pcour dans la liste des exécutables
   //execSuiv, le suivant de pcour dans la liste des exécutables
   if (pcour==NULL) 
      { 
         if(elemExecPrec != NULL) *elemExecPrec = execPrec;
         result = false;
      }
   else 
      {
         pcour->_isActive = true ;
         if ( execPrec == NULL ) 
            {
               //premier dans la liste des executables
               _start = pcour;
            }
         else 
            {
               execPrec->nextInActiveList = pcour ;
            }
         if( execSuiv == NULL ) 
            {
               //dernier dans la liste des executables
               _last = pcour;
            }
         else 
            {
               execSuiv->previousInActiveList = pcour;
            }
         pcour->previousInActiveList = execPrec ;
         OMASSERTM( pcour != execPrec, "" ) ;
         
         pcour->nextInActiveList = execSuiv;
         OMASSERTM( pcour != execSuiv, "" ) ;

         if(elemExecPrec!=NULL) *elemExecPrec=execPrec;
         result = true ;
      }
   //test integrity of data
   if ( _lastOfSuperList != NULL ) 
      OMASSERTM( findInSuperList ( _lastOfSuperList->listeElem ) == _lastOfSuperList, "" ) ;
   if ( _last != NULL )
     OMASSERTM( find ( _last->listeElem) == _last, "" ) ;
  return result ;
}

bool DoubleList::suspend

(

ReferenceObjectHandle *

M

)

pour supprimer un module de la liste des modules à compute

Parameters:

M

: la référence du module à ajouter

Returns:

: true si l'opération a échoué

Definition at line 246 of file OMKDoubleList.cpp.

References OMK::DoubleListElement::_isActive, _last, _start, find(), OMK::DoubleListElement::nextInActiveList, and OMK::DoubleListElement::previousInActiveList.

{
  DoubleListElement * elem = find(M);
  if( elem != NULL ) 
     {//l'objet n'est pas déjà détruit ou est une entité
      DoubleListElement * prec=elem->previousInActiveList;
      DoubleListElement * suiv=elem->nextInActiveList;
      if(prec!=NULL) {
        prec->nextInActiveList=suiv;
      }
      else {//l'élément détruit était en tete
        _start=suiv;
      };
      if(suiv!=NULL) {
        suiv->previousInActiveList=prec;
      }
      else {
        _last=prec;
      };
      //l'élément n'appartient plus à la liste des modules à exécuter
      elem->previousInActiveList=NULL;
      elem->nextInActiveList=NULL;
      elem->_isActive = false ;
      return false;
  }
  else {
    return true;
  }
}

DoubleListElement * DoubleList::superListBegin

(

)

superListBegin

Returns:

first element of the super list

Definition at line 310 of file OMKDoubleList.cpp.

References _startOfSuperList.

{
   return _startOfSuperList;
}

DoubleListElement * DoubleList::superListNext

(

DoubleListElement *

currentElement

)

get the element following the iterator passed as parameter in the super list

Parameters:

currentElement

the current iterator

Returns:

an iterator to the following element, NULL if the current element is the last one

Definition at line 315 of file OMKDoubleList.cpp.

References OMK::DoubleListElement::nextInSuperList, and OMASSERTM.

{
   if(pcour == NULL) 
      {
         cerr<<"DoubleList::superListNext WARNING:Suivant de NULL inexistant"<<endl;
         return NULL;
      }
   else 
      {
         OMASSERTM( pcour->nextInSuperList != pcour, "" ) ;
         return pcour->nextInSuperList ;
      }
}

DoubleListElement * DoubleList::begin

(

)

begin

Returns:

the first element of the active list

Definition at line 329 of file OMKDoubleList.cpp.

References _start.

{
   return _start;
}

DoubleListElement * DoubleList::next

(

DoubleListElement *

pcour

)

get the element following the iterator passed as parameter in the active list

Parameters:

currentElement

the current iterator

Returns:

an iterator to the following element, NULL if the current element is the last one

Definition at line 334 of file OMKDoubleList.cpp.

References OMK::DoubleListElement::nextInActiveList, and OMASSERTM.

Referenced by OMK::FrameScheduler::runStep().

{
   if(pcour == NULL) 
      {
         cerr<<"DoubleList::next WARNING:Suivant de NULL inexistant"<<endl;
         return NULL;
      }
   else 
      {
         OMASSERTM( pcour->nextInActiveList != pcour, "" ) ;
         return pcour->nextInActiveList;
      }
}

DoubleListElement * DoubleList::findInSuperList

(

ReferenceObjectHandle *

p

)

[protected]

Find an element in the super list.

Parameters:

p

the element to look for

Returns:

NULL it it wasn't found, the DoubleListElement otherwise

Definition at line 276 of file OMKDoubleList.cpp.

References _startOfSuperList, OMK::DoubleListElement::listeElem, OMK::DoubleListElement::nextInSuperList, and OMASSERTM.

Referenced by activate(), insert(), and remove().

{
   DoubleListElement * pcour=_startOfSuperList;
   DoubleListElement * resul=NULL;
   while( ( pcour != NULL ) && 
          ( resul == NULL) ) 
      {
         if( pcour->listeElem == p ) 
            {
               resul=pcour;
            }
         OMASSERTM( pcour != pcour->nextInSuperList, "" ) ;
         pcour = pcour->nextInSuperList ;
      }
   return resul;
}

DoubleListElement * DoubleList::find

(

ReferenceObjectHandle *

p

)

[protected]

Find an element in the active list.

Parameters:

p

the element to look for

Returns:

NULL it it wasn't found, the DoubleListElement otherwise

Definition at line 293 of file OMKDoubleList.cpp.

References _start, OMK::DoubleListElement::listeElem, OMK::DoubleListElement::nextInActiveList, and OMASSERTM.

Referenced by activate(), insert(), remove(), and suspend().

{
   DoubleListElement * pcour = _start;
   DoubleListElement * resul = NULL;
   while( ( pcour != NULL ) &&
          ( resul == NULL ) ) 
      {
        if(pcour->listeElem==p) 
           {
              resul = pcour;
           }
        OMASSERTM( pcour != pcour->nextInActiveList, "" ) ;
        pcour = pcour->nextInActiveList;
     }
  return resul;
}

---

Member Data Documentation

DoubleListElement* OMK::DoubleList::_startOfSuperList [protected]

first element in super list

Definition at line 136 of file OMKDoubleList.h.

Referenced by activate(), findInSuperList(), insert(), push_back(), push_front(), remove(), and superListBegin().

DoubleListElement* OMK::DoubleList::_lastOfSuperList [protected]

last element in super list

Definition at line 140 of file OMKDoubleList.h.

Referenced by activate(), insert(), push_back(), push_front(), and remove().

DoubleListElement* OMK::DoubleList::_start [protected]

fisrt element in active liste

Definition at line 144 of file OMKDoubleList.h.

Referenced by activate(), begin(), find(), remove(), and suspend().

DoubleListElement* OMK::DoubleList::_last [protected]

last element in active list

Definition at line 148 of file OMKDoubleList.h.

Referenced by activate(), insert(), remove(), and suspend().

---