OMKFifo.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 FifoHEADER
#define FifoHEADER

#include <OMKAbstractFifo.h>
#include <typeinfo>
#include <vector>
#include "OMKTracer.h"

namespace OMK
{

template < typename T>
class Fifo : public AbstractFifo <T>
{
 public:
  using AbstractFifo <T>::_fifoSize ;
 public :
   Fifo (const int taille) ;


   virtual ~Fifo () ;

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


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

   virtual void set (const T& val, const Date & date) ;


   virtual void setInPlace ( const T& val, const Date & date) ;


   virtual T& getNextPlaceHolder() ;


   virtual void clear () ;


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


   virtual void printDebuggingInformation(void) const ;

protected :
   class ValeurDate 
   {
   public:
      ValeurDate() : dateValeur( -2 ) {}
      Date dateValeur ;
      T valeur ;    
   };
   
   std::vector<ValeurDate> _tab ;

   unsigned int _numberOfValues ;

   unsigned int _mostRecentValueIndex ;
} ; // Fifo





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

template <typename T>
Fifo<T>::Fifo ( const int size )
: AbstractFifo< T >( size ),
_tab( size ),
_numberOfValues( 0 ),
_mostRecentValueIndex( size - 1 )
{
}



template <typename T> 
Fifo<T>::~Fifo (void) 
{
}

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

template <typename T> 
const Date & Fifo<T>::getPreceedingDate (unsigned int i) const 
{
   OMASSERTM ( i < _fifoSize - 2, "" ) ;
   int indice = (_fifoSize + _mostRecentValueIndex - i ) % _fifoSize ;
   return _tab[indice].dateValeur ;
}

template <typename T> 
const T& Fifo<T>::getPreceedingValue (unsigned int i) const {
   OMASSERTM( i < _fifoSize - 2, "" ) ;
   int indice = (_fifoSize + _mostRecentValueIndex - i ) % _fifoSize ;
   return _tab[indice].valeur ;
}

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

template <typename T>
void Fifo<T>::set (const T& newValue, const Date & dateOfNewValue) 
{
   unsigned int newMostRecentValueIndex = ( _mostRecentValueIndex + 1 ) % _fifoSize ;

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

   _tab[newMostRecentValueIndex].valeur = newValue ;

   _mostRecentValueIndex = newMostRecentValueIndex ;
}

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

   Date & 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
   OMASSERTM(&(_tab[newMostRecentValueIndex].valeur) == &newValue, "" ) ;

   _mostRecentValueIndex = newMostRecentValueIndex ;
}


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

template <typename T>
unsigned int Fifo<T>::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 
   OMASSERTM( _fifoSize >=  2, "" ) ;
   if (res >= _fifoSize - 1) {
      res = _fifoSize - 2 ;
   }
   return res ;
}

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

template <typename T>
void Fifo<T>::clear() {
   _numberOfValues = 0 ;
}

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

template <typename T>
void Fifo<T>::printDebuggingInformation (void) const 
{
   std::cerr<< "Fifo<"<<typeid(T).name()<<">::"<<this<<"::printDebuggingInformation()"<<std::endl ;
   AbstractFifo<T>::printDebuggingInformation() ;
   std::cerr << "number of valid values : " << _numberOfValues << std::endl
        << "last written value at : " << _mostRecentValueIndex << std::endl ;
}
} // namespace OMK

#endif

---