---

PsSpecialisedMomeOuput.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 <PsOutput.h>
#include <PsMomeOutput.h>

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


void PsMomeOutput<PsList<PsInt> >::extract(istream & in) {
   //on s'en fiche de in, puisqu'on a déjà les infos sous la bonne forme !
   if(_myDataMemoryManager->localAddressToGlobal(_mesDonnees->usedOutputDataOffset)!=NULL){
      
   }
   if(_myDataMemoryManager->localAddressToGlobal(_mesDonnees->historyFifoOffsetsOutputAsc)!=NULL){

   }
   if(_myDataMemoryManager->localAddressToGlobal(_mesDonnees->principalAliasDataOffset)!=NULL){

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

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

inline PsMomeOutput<PsList<PsInt> >::PsMomeOutput (const PsName & nom,
                                         PsSimulatedObject *prop,
                                         const int tailleFile,
                                         PsPolatorNT * interpolateur)
   : PsOutput<PsList<PsInt> > (nom,prop,tailleFile,interpolateur), _monNom(nom)
{
   //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;

   //cerr<<"PsMomeOutput<Type>::PsMomeOutput "<<endl;

   _monControleur=dynamic_cast<PsMomeController *>(owner->Controleur());

   if (_monControleur!=NULL) {

      _myDataMemoryManager=PsMomeController::outputDataSharedMemoryManager;

      _mesDonnees = _monControleur->creerDonneesOutput(prop->Nom(),nom);

      _myDataMemoryManager->lock();

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

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

         int tailleReel = tailleFile + _polator->getNumberOfNeededValuesForMaxPrecisionPolation();

         CurrentAllocator titi(prop->Nom(),CurrentAllocator::Write);

         _history = new(_myDataMemoryManager) PsnMomeFifo < PsList<PsInt>  > ( tailleReel , _myDataMemoryManager ) ;

         _mesDonnees->historyFifoOffset=_myDataMemoryManager->globalAddressToLocal( _history );
         
      }
      else {

         _history = (PsnMomeFifo <PsList<PsInt>  > *)_myDataMemoryManager->localAddressToGlobal(_mesDonnees->historyFifoOffset);

      }

      _myDataMemoryManager->unlock();
      
   }
   else {
      cerr<<"PsMomeOutput<"<<typeid(PsList<PsInt> ).name()<<">::constructeur"
          <<"Controleur de type Mome attendu, mais de type "<<typeid(prop->Controleur()).name()<<endl;
      PsController::error("");
   }

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

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

inline PsMomeOutput<PsList<PsInt> >::~PsMomeOutput (void)
{
   _monControleur->invalidateOutput(owner->Nom(),_monNom);
   //cerr<<"Fin destructeur de PsMomeOutput <"<<typeid(Type).name()<<">"<<endl;
}

//-----------------------------------------------------------------
void PsMomeOutput<PsList<PsInt> >::setValidity(bool b) {
   PsOutput<PsList<PsInt> >::setValidity(b);
   _mesDonnees->_validity=b;
}

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

void PsMomeOutput<PsList<PsInt> >::setOutputAscendant(PsOutput<PsList<PsInt> > * output)  {
   PsOutput<PsList<PsInt> >::setOutputDescendant(output);
   PsMomeOutput<PsList<PsInt> > * laOutput  = dynamic_cast<PsMomeOutput<PsList<PsInt> > *>(output);
   _mesDonnees->historyFifoOffsetsOutputAsc=_myDataMemoryManager->globalAddressToLocal(laOutput->_mesDonnees);
}

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

void PsMomeOutput<PsList<PsInt> >::setOutputDescendant(PsOutput<PsList<PsInt> > * output)  {
   PsOutput<PsList<PsInt> >::setOutputDescendant(output);
   PsMomeOutput<PsList<PsInt> > * laOutput  = dynamic_cast<PsMomeOutput<PsList<PsInt> > *>(output);
   _mesDonnees->principalAliasDataOffset=_myDataMemoryManager->globalAddressToLocal(laOutput->_mesDonnees);
}

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

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

const PsList<PsInt>  & PsMomeOutput<PsList<PsInt> >::get(int & validiteRes,
                                     const int niveauInterpol,
                                     const PsDate & deltaT) const
{
   try {
      return PsOutput<PsList<PsInt> >::get(validiteRes,niveauInterpol,deltaT);
   }
   catch (PsUnInitialisedOutputException & s) {
      //retry after syncing the memory
      _myDataMemoryManager->strongSynchronizeRegion(_mesDonnees->historyFifoOffset,
                                                    _mesDonnees->historyLength);
      PsMomeOutput<PsList<PsInt> > * uneCopieNonConst = const_cast< PsMomeOutput<PsList<PsInt> > *> (this);
      assert (uneCopieNonConst != 0 );
      uneCopieNonConst->extract();
      return PsOutput<PsList<PsInt> >::get(validiteRes,niveauInterpol,deltaT);      
   }
}

void PsMomeOutput <PsList <PsInt> >::set (const PsList< PsInt > & val) {
   cerr<<"PsOutput <PsList <PsInt> >::set ";
   const PsDate & date = Controleur ()->getSimulatedDate () ;
   CurrentAllocator titi(owner->Nom());
   assert (CurrentAllocator::name != NULL) ;
   if (_validity) {  //mise a jour de la valeur de l'attribut (par le referentiel owner)
      const PsList <PsInt> & ancValue=_history->getVal();

      _history->set (val, date) ;

      if(val!=ancValue) {
         notifyConnectedSensitiveInputs();
      }
   }
   else {
      _history->set (val, date) ;
      setValidity(true) ;
   }   
   //cerr<<" PsOutput <PsList <PsInt> >::set fin "<<endl;
}

---