---

PsnDoubleList.cxx

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 <PsnDoubleList.h>

#include "PsnReferenceObjectHandle.h"

PsnDoubleList::PsnDoubleList() {
  _startOfSuperList=NULL;
  _lastOfSuperList=NULL;
  _start=NULL;
  _last=NULL;
}

 
bool PsnDoubleList::push_front(PsnReferenceObjectHandle * M) {
 PsnDoubleListElement * elem=new PsnDoubleListElement(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 PsnDoubleList::push_back(PsnReferenceObjectHandle * M) {
 PsnDoubleListElement * elem=new PsnDoubleListElement(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 PsnDoubleList::insert(PsnReferenceObjectHandle * M) {
   PsnDoubleListElement * elem=new PsnDoubleListElement(M);
   PsnDoubleListElement * pcour=_startOfSuperList;
   PsnDoubleListElement * 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;
      }
   }
   return false;
}

bool PsnDoubleList::remove(PsnReferenceObjectHandle * M) {
  PsnDoubleListElement * 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 {
      PsnDoubleListElement * prec=elem->previousInSuperList;
      PsnDoubleListElement * 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;
    }
  }
  return false;
}


bool PsnDoubleList::activate(PsnReferenceObjectHandle * M, PsnDoubleListElement ** elemExecPrec) 
{
  PsnDoubleListElement * pcour=_startOfSuperList;
  PsnDoubleListElement * resul=NULL;
  PsnDoubleListElement * execSuiv=_start;
  PsnDoubleListElement * 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) 
           {
              resul=pcour;
           }
        else 
           {
              if( pcour->nextInActiveList != NULL ) 
                 {//l'élément courant est dans la liste des exec
                    execPrec = pcour ;
                    execSuiv = pcour->nextInActiveList;
                 }
              else 
                 {  // pcour is the last one of the active list
                    // or is not present in the active list
                    if ( pcour->previousInActiveList != NULL )
                       {
                          // pcour is in active list
                          execSuiv = NULL;
                          execPrec = pcour;  
                       }
                    else
                       {
                          // pcour is either the only element in the active list
                          // or is not in the active list
                          if ( pcour == _start )
                             { 
                                //pcour is the only element in the active list
                                execSuiv = NULL;
                                execPrec = pcour;
                             }
                           else
                              {
                                 // nothing to do
                              }
                       }
                 }
              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;
    return false;
  }
  else {
    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;
    pcour->nextInActiveList=execSuiv;
    if(elemExecPrec!=NULL) *elemExecPrec=execPrec;
    return true ;
  }
}

bool PsnDoubleList::suspend(PsnReferenceObjectHandle * M) {
  PsnDoubleListElement * elem=find(M);
  if(elem!=NULL) {//l'objet n'est pas déjà détruit ou est un entité
      PsnDoubleListElement * prec=elem->previousInActiveList;
      PsnDoubleListElement * 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;
      return false;
  }
  else {
    return true;
  }
}

PsnDoubleListElement * PsnDoubleList::findInSuperList(PsnReferenceObjectHandle * p) {
  PsnDoubleListElement * pcour=_startOfSuperList;
  PsnDoubleListElement * resul=NULL;
  while((pcour!=NULL)&&(resul==NULL)) {
    if(pcour->listeElem==p) {
      resul=pcour;
    }
    pcour=pcour->nextInSuperList;
  }
  return resul;
}

PsnDoubleListElement * PsnDoubleList::find(PsnReferenceObjectHandle * p) {
  PsnDoubleListElement * pcour=_start;
  PsnDoubleListElement * resul=NULL;
  while((pcour!=NULL)&&(resul==NULL)) {
    if(pcour->listeElem==p) {
      resul=pcour;
    }
    pcour=pcour->nextInActiveList;
  }
  return resul;
}

PsnDoubleListElement * PsnDoubleList::superListBegin() {
  return _startOfSuperList;
}

PsnDoubleListElement * PsnDoubleList::superListNext(PsnDoubleListElement * pcour) {
  if(pcour == NULL) {
    cerr<<"PsnDoubleList::superListNext WARNING:Suivant de NULL inexistant"<<endl;
    return NULL;
  }
  else {
    return pcour->nextInSuperList;
  }
}

PsnDoubleListElement * PsnDoubleList::begin() {
  return _start;
}

PsnDoubleListElement * PsnDoubleList::next(PsnDoubleListElement * pcour){
  if(pcour == NULL) {
    cerr<<"PsnDoubleList::next WARNING:Suivant de NULL inexistant"<<endl;
    return NULL;
  }
  else {
    return pcour->nextInActiveList;
  }
}

---