---

PsMomeOutput.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 PsMomeOutputHEADER
#define PsMomeOutputHEADER

class PsnOutputSharedData;
class PsMomeController;

#include "PsEmptyFifoException.h"

template <typename Type>
class PsMomeOutput : public PsOutput<Type> {
public :
   PsMomeOutput (const PsName & outputName, 
                 PsSimulatedObject & owner, 
                 const int historyLength,
                 PsPolatorNT * polator = NULL ) ;


   virtual ~PsMomeOutput (void) ;

   virtual void setValidity(bool);

   virtual void setUsedOutput(PsOutput<Type>  * output)  ;
   virtual void setDescendantOutput(PsOutput<Type> * output) ;
   virtual void extract(istream & = cin) ;
   virtual const Type & get (int & validiteRes,
                             const int niveauInterpol,
                             const PsDate & deltaT,
                             Type & resultPlaceHolder) const ;
   virtual void set (const Type & val) ; 
protected:
   PsnOutputSharedData * _mesDonnees;
   PsDate _dateDernierChangementValeur;
   PsMomeController * _monControleur;
   PsnRelaxedMemoryManager * _myDataMemoryManager;
} ; // PsMomeOutput


#include <PsMomeController.h>
#include <PsnOutputSharedData.h>

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

template <typename Type>
void PsMomeOutput<Type>::extract(istream & in) {
   //on s'en fiche de in, puisqu'on a déjà les infos sous la bonne forme !
   //cerr<<"PsMomeOutput<Type>::extract"<<endl;
   if(_myDataMemoryManager->localAddressToGlobal(_mesDonnees->usedOutputDataOffset)!=NULL){
      
   }
   if(_myDataMemoryManager->localAddressToGlobal(_mesDonnees->principalAliasDataOffset)!=NULL){

   }
   if(_mesDonnees->_validity!=_validity){
      setValidity(_mesDonnees->_validity);
   }
      
}

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

template <typename Type>
inline PsMomeOutput<Type>::PsMomeOutput (const PsName & nom,
                                         PsSimulatedObject & prop,
                                         const int tailleFile,
                                         PsPolatorNT * interpolateur)
   : PsAttribute(prop,nom),
     PsOutput<Type> (nom,prop,tailleFile,interpolateur)
{
   //cerr<<"PsMomeOutput<Type>::PsMomeOutput "<<endl;
   //on détruit la file classique, et on en crée (ou en en récupère) une adaptée, et on recole les morceaux
   delete _history;

   //Their is 4 cases : either we need to create a PsnMomeWriterFifo or a PsnMomeReaderFifo and either the internal data has allready been created or not


   _monControleur=dynamic_cast<PsMomeController *>(&_owner.getController());

   if (_monControleur!=NULL) {

      _myDataMemoryManager = PsMomeController::outputDataSharedMemoryManager;

      _mesDonnees = _monControleur->creerDonneesOutput(_owner.getName(),nom);

      _myDataMemoryManager->lockIfNeeded();

      _myDataMemoryManager->synchronizeAfterLock((void *)_mesDonnees,sizeof(PsnOutputSharedData));

      if (_myDataMemoryManager->invalidOffset(_mesDonnees->historyFifoOffset)) {

         if (tailleFile < _polator->getNumberOfNeededValuesForMaxPrecisionPolation() ) {
            cerr<<"Taille de file trop petite ("<<tailleFile
                <<") alors que la output "<<nom<<" de "<<_owner.getName()
                <<" nécessite "<<_polator->getNumberOfNeededValuesForMaxPrecisionPolation()
                <<" valeurs pour un fonctionnement correct "<<endl;
            PsController::error("PsMomeOutput::constructeur");
         }
#ifdef _DEBUGCREATIONOUTPUT
         cerr<<"PsMomeOutput<Type>::PsMomeOutput : creation d'une file Mome"<<endl;
#endif
         
         if ( _monControleur->getObjectDescriptor().getProcess () == _owner.getObjectDescriptor().getProcess () ) {
            _history = new PsnMomeWriterFifo < Type > ( tailleFile , _myDataMemoryManager ) ;
         }
         else {
            _history = new PsnMomeReaderFifo <Type > ( tailleFile , _myDataMemoryManager ) ;
         }
#ifdef _DEBUGCREATIONOUTPUT
         cerr<<"PsMomeOutput<Type>::PsMomeOutput : file Mome créée "<<endl;
#endif
         _mesDonnees->historyFifoOffset=_myDataMemoryManager->globalAddressToLocal( ((PsnMomeFifo<Type> *)_history)->fifo() );
         
      }
      else {
         if (_monControleur->getObjectDescriptor().getProcess () == _owner.getObjectDescriptor().getProcess () ) {

            _history = new PsnMomeWriterFifo <Type > (_myDataMemoryManager->localAddressToGlobal(_mesDonnees->historyFifoOffset), tailleFile);
         }
         else {
            _history = new PsnMomeReaderFifo <Type > ( _myDataMemoryManager->localAddressToGlobal(_mesDonnees->historyFifoOffset),tailleFile); 
         }

      }

      _myDataMemoryManager->unlockIfNeeded();
      
   }
   else {
      cerr<<"PsMomeOutput<"<<typeid(Type).name()<<">::constructeur"
          <<"Controleur de type Mome attendu, mais de type "<<typeid(_owner.getController()).name()<<endl;
      PsController::error("");
   }

   _polator->setFifo(_history);
   //cerr<<"PsMomeOutput<Type>::PsMomeOutput fin de creation de la MomeOutput"<<endl;
}

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

template <typename Type>
inline PsMomeOutput<Type>::~PsMomeOutput (void)
{
   //cerr<<"PsMomeOutput <"<<typeid(Type).name()<<">::~PsMomeOutput()"<<endl;
   //delete _history ;
   _history = NULL ;
   _monControleur->invalidateOutput(_owner.getName(),_name);
   //cerr<<"Fin destructeur de PsMomeOutput <"<<typeid(Type).name()<<">"<<endl;
}

//-----------------------------------------------------------------
#include <unistd.h>
template <typename Type>
void PsMomeOutput<Type>::setValidity(bool b) {
   PsOutput<Type>::setValidity(b);
   _mesDonnees->_validity=b;
}


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

template <typename Type>
void PsMomeOutput<Type>::setDescendantOutput(PsOutput<Type> * output)  {
   //PsOutput<Type>::setDescendantOutput(output);
   assert (false) ;
   PsMomeOutput<Type> * laOutput  = dynamic_cast<PsMomeOutput<Type> *>(output);
   _mesDonnees->principalAliasDataOffset=_myDataMemoryManager->globalAddressToLocal(laOutput->_mesDonnees);
}

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

template <typename Type>
void PsMomeOutput<Type>::setUsedOutput(PsOutput<Type> * output)  {
   PsOutput<Type>::setUsedOutput(output);
   PsMomeOutput<Type> * laOutput  = dynamic_cast<PsMomeOutput<Type> *>(output);
   _mesDonnees->usedOutputDataOffset=_myDataMemoryManager->globalAddressToLocal(laOutput->_mesDonnees);
}

template <typename Type>
const Type & PsMomeOutput<Type>::get(int & validiteRes,
                                     const int niveauInterpol,
                                     const PsDate & deltaT,
                                     Type & resultPlaceHolder) const
{
#ifdef _DEBUGATTRIBUTSMOME
   cerr<<"PsMomeOutput<"<<typeid(Type).name()<<">::"<<this<<"::get de "<<_name<<" "<<_owner.getName()<<endl;
   cerr<<"file : "<<_history<<endl;
#endif
   if (! _validity) {
      _myDataMemoryManager->syncStepSyncedMemory();
      PsMomeOutput<Type> * uneCopieNonConst = const_cast< PsMomeOutput<Type> *> (this);
      uneCopieNonConst->extract();
   }
   try {
      try {
         return PsOutput<Type>::get(validiteRes,niveauInterpol,deltaT, resultPlaceHolder);
      }
      catch (PsUnInitialisedOutputException & s) {
         ((PsnMomeFifo <Type > *) _history )->resyncFifo (_myDataMemoryManager) ; 
         PsMomeOutput<Type> * uneAutreCopieNonConst = const_cast< PsMomeOutput<Type> *> (this);
         //assert (uneCopieNonConst != 0 );
         uneAutreCopieNonConst->extract();
         cerr<<"retry after syncing the memory of "<<_name<<" of object "<<_owner.getName()<<endl;
         return PsOutput<Type>::get(validiteRes,niveauInterpol,deltaT, resultPlaceHolder);      
      }
   }
   catch (PsEmptyFifoException & s) {
      cerr<<"PsMomeOutput<Type>::get : la file est vraiment vide !"<<endl;
      return PsOutput<Type>::get(validiteRes,niveauInterpol,deltaT, resultPlaceHolder);
   }
}


template <typename Type>
void PsMomeOutput<Type>::set ( const Type & val) {
#ifdef _DEBUGATTRIBUTSMOME
   cerr<<"PsMomeOutput<"<<typeid(Type).name()<<">::"<<this<<"set "<<_name<<" de "<<_owner.getName()<<" "<<val<<endl;
#endif
   HeapStackTop specialContext(_myDataMemoryManager);
   //assert(HeapStackTop::globalMemoryManager != NULL );
   PsOutput< Type >::set(val) ;
   //cerr<<"PsMomeOutput<Type>::set fait"<<endl;
}


#endif

---