---

PsnFifo.h

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 
 *
 */
#ifndef PsnFifoHEADER
#define PsnFifoHEADER

#include <PsnAbstractFifo.h>
#include <typeinfo>
#include <PsnArray.h>

template < typename Type >
class PsnFifo : public PsnAbstractFifo <Type>
{
   
public :
   PsnFifo (const int taille) ;


   virtual ~PsnFifo () ;

   virtual const Type & getPreceedingValue (const unsigned int indice) const ;


   virtual const PsDate & getPreceedingDate(const unsigned int indice) const ;
   

   virtual void set (const Type & val, const PsDate & date) ;


   virtual void setInPlace ( const Type & val, const PsDate & date) ;


   virtual Type & getNextPlaceHolder() ;


   virtual void clear () ;


   virtual unsigned int getNumberOfPresentValues( int maxCherche = -1 ) const ;


   virtual void printDebuggingInformation(void) const ;

protected :
   class valeurDate 
   {
   public:
      valeurDate() : dateValeur(-2) {
      }
      PsDate dateValeur;
      Type   valeur ;    
   };
   
   PsnAbstractArray <valeurDate> * _tab ;

   unsigned int _numberOfValues ;

   unsigned int _mostRecentValueIndex ;
} ; // PsnFifo





//------------------------------------------------------------------------

template <typename Type> 
PsnFifo<Type>::PsnFifo (const int taille) : 
   PsnAbstractFifo <Type> (taille), 
   _numberOfValues ( 0 ),
   _mostRecentValueIndex (taille-1) 
{
   _tab = new PsnArray < valeurDate >  (taille) ;
   //cerr<<"PsnFifo<Type>::PsnFifo created "<<endl;
}



template <typename Type> 
PsnFifo<Type>::~PsnFifo (void) {
   if ( _tab != NULL ) delete _tab ;
}

//------------------------------------------------------------------------

template <typename Type> 
const PsDate & PsnFifo<Type>::getPreceedingDate (unsigned int i) const 
{
   assert ( i < _fifoSize - 2 ) ;
   int indice = (_fifoSize + _mostRecentValueIndex - i ) % _fifoSize ;
   return (*_tab) [indice].dateValeur ;
}

template <typename Type> 
const Type & PsnFifo<Type>::getPreceedingValue (unsigned int i) const {
   assert ( i < _fifoSize - 2 ) ;
   int indice = (_fifoSize + _mostRecentValueIndex - i ) % _fifoSize ;
   return (*_tab) [indice].valeur ;
}

//------------------------------------------------------------------------

template <typename Type>
void PsnFifo<Type>::set (const Type & newValue, const PsDate & dateOfNewValue) {
   //cerr<<"PsnFifo<"<<typeid(Type).name()<<">::"<<this<<"::set("<<newValue<<", "<<dateOfNewValue<<")"<<endl;
   unsigned int newMostRecentValueIndex = ( _mostRecentValueIndex + 1 ) % _fifoSize ;

   PsDate & dateOfMostRecentValue((*_tab)[_mostRecentValueIndex].dateValeur) ;
   
   if (dateOfMostRecentValue < dateOfNewValue ) {
      (*_tab)[newMostRecentValueIndex].dateValeur = dateOfNewValue ;
      if ( _numberOfValues != _fifoSize ) {
         _numberOfValues ++ ;
      }
    }

   //cerr<<"newValue "<<newValue <<", old Value"<<(*_tab)[newMostRecentValueIndex].valeur<<endl;
   (*_tab)[newMostRecentValueIndex].valeur = newValue ;
   //cerr<<"newValue "<<(*_tab)[newMostRecentValueIndex].valeur <<endl;

   _mostRecentValueIndex = newMostRecentValueIndex ;
}

template <typename Type>
void PsnFifo<Type>::setInPlace ( const Type & newValue, const PsDate & dateOfNewValue ) 
{
   unsigned int newMostRecentValueIndex = ( _mostRecentValueIndex + 1 ) % _fifoSize ;

   PsDate & dateOfMostRecentValue((*_tab)[_mostRecentValueIndex].dateValeur) ;
   
   if (dateOfMostRecentValue < dateOfNewValue ) {
      (*_tab)[newMostRecentValueIndex].dateValeur = dateOfNewValue ;
      if ( _numberOfValues != _fifoSize ) {
         _numberOfValues ++ ;
      }
    }

   //this assertion will fail if setInplace is used a a different simulation step than getNextPlaceHolder
   // or if newValue isn't a reference to a value of the container
   assert (&((*_tab)[newMostRecentValueIndex].valeur) == &newValue ) ;

   _mostRecentValueIndex = newMostRecentValueIndex ;
}


template <typename Type>
Type & PsnFifo<Type>::getNextPlaceHolder() 
{
   return (*_tab)[( _mostRecentValueIndex + 1 ) % _fifoSize].valeur ;
}

template <typename Type>
unsigned int PsnFifo<Type>::getNumberOfPresentValues( int maxCherche ) const {
   unsigned int res ;
   if ( (maxCherche == -1) || (_numberOfValues < (unsigned int) maxCherche) ) {
      res = _numberOfValues ;
   }
   else {
      res = maxCherche ; 
   }
   //for multithreading reasons, limit the results to _fifoSize - 2 
   assert (_fifoSize  >=  2) ;
   if (res >= _fifoSize - 1) {
      res = _fifoSize - 2 ;
   }
   return res ;
}

//------------------------------------------------------------------------

template <typename Type>
void PsnFifo<Type>::clear() {
   _numberOfValues = 0 ;
}

//------------------------------------------------------------------------

template <typename Type>
void PsnFifo<Type>::printDebuggingInformation (void) const {
   cerr<< "PsnFifo<"<<typeid(Type).name()<<">::"<<this<<"::printDebuggingInformation()"<<endl ;
   PsnAbstractFifo<Type>::printDebuggingInformation() ;
   cerr << "number of valid values : " << _numberOfValues << endl
        << "last written value at : " << _mostRecentValueIndex << endl
        << "values stored in array : "<< endl;
   _tab->printDebuggingInformation( _fifoSize ) ;
}

#endif

---