OMKDoubleList.cpp

Go to the documentation of this file.

/*
 * This file is part of openMask © INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software
 * 
 * The Software has been developped within the Siames Project. 
 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200
 *  
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 
 * for the software may use this file in accordance with that specific license
 *
 */
#include <OMKDoubleList.h>
#include <OMKDoubleListElement.h>
#include "OMKReferenceObjectHandle.h"
#include "OMKTracer.h"
using namespace std ;
using namespace OMK ;


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

 
bool DoubleList::push_front(ReferenceObjectHandle * M) {
 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 * M) {
 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 * M) 
{
   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 * M) 
{
   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) 
{
   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) 
{
  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::findInSuperList(ReferenceObjectHandle * p) 
{
   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) 
{
   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;
}

DoubleListElement * DoubleList::superListBegin() 
{
   return _startOfSuperList;
}

DoubleListElement * DoubleList::superListNext(DoubleListElement * pcour)
{
   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() 
{
   return _start;
}

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

---