---

PsnMirrorObjectHandle.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 <PsnMirrorObjectHandle.h>
#include <PsSimulatedObject.h>
#include <PsPvmController.h>
#include <PsnPvmSvmLink.h>
#include <PsnPvmMessage.h>
#include "PsEvent.h"
#include "PsObjectDescriptor.h"
#include "PsnSvm.h"
//-----------------------------------------------------------------------------
//recevoir la liste des outputs exportables

PsnMirrorObjectHandle::PsnMirrorObjectHandle (PsSimulatedObject & objetSimul) : 
   PsnObjectHandle (objetSimul),
   _dateOfLastUse ( objetSimul.getController().getSimulatedDate() ),
   _registered ( false )
{
   PsName processOfReferenceObject = getSimulatedObject().getObjectDescriptor ().getProcess () ;
   
   _linkToReferencesProcess = dynamic_cast<PsPvmController &>(getSimulatedObject().getController()).getDistributedVirtualMachine()->getLinkToProcessNamed (processOfReferenceObject) ;

  assert ( _linkToReferencesProcess != NULL ) ;
}

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

PsnMirrorObjectHandle::~PsnMirrorObjectHandle () {

}

void PsnMirrorObjectHandle::attributeRead () 
{
   PsnObjectHandle::attributeRead() ;
   if ( ! _registered )
      {
         //cerr<<"PsnMirrorObjectHandle::attributeRead : new registration needed"<<endl;
         registerToReferenceObject () ;
      }
}

//-----------------------------------------------------------------------------
// s'abonner Flot de Donnees aupres du referentiel

void PsnMirrorObjectHandle::registerToReferenceObject () 
{
   // should only be called once by the creator of the mirror 
   assert ( _registered == false ) ;
#ifdef _DEBUGPVMSYNCHRO
   cerr << "PsnMirrorObjectHandle::registerToReferenceObject: mirror registering to referential" << endl ;
#endif
   sendRequestToReferenceObject (Registration) ;
   _registered = true ;

   // until SGI Perfomer becomes compatible with exception handling, request initial values from the referential immediatly, and wait for answer
   PsnPvmUnicastMessage * urgentRequest = new PsnPvmUnicastMessage ( _linkToReferencesProcess->getTID() ) ;

   urgentRequest->insertTimeStamp( getSimulatedObject().getController().getSimulatedDate() ) ;

   getSimulatedObject().getName().pack ( *urgentRequest ) ;

   PsPvmController &  realController = dynamic_cast<PsPvmController & > ( _myObject.getController() ) ;

   realController.getProcessName ().pack ( *urgentRequest ) ;

   urgentRequest->send ( PsnPvmMessage::MirrorNeedsInitialValues ) ;

   realController.waitForAnswerToBlockingRequest(PsnPvmMessage::InitialValuesForMirror) ;
}

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

void  PsnMirrorObjectHandle::cancelRegistrationToReferenceObject () 
{
#ifdef _DEBUGPVMSYNCHRO
   cout << "PsnMirrorObjectHandle::cancelRegistrationToReferenceObject" << endl ;
#endif
   sendRequestToReferenceObject (CancelRegistration) ;
   _registered = false ;
}

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

void PsnMirrorObjectHandle::insertInStream (ostream & out) const {
   out << "PsnMirrorObjectHandle::insertInStream nothing to insert" << endl ;
}

//-----------------------------------------------------------------------------
void PsnMirrorObjectHandle::unpack (PsIncomingSynchronisationMessage & in) 
{
   PsnRequestType typeMess ;
   int messageType ;

   //make sure the mirror is still needed
   if ( getAttributeRead() )
      {
         _dateOfLastUse = _myObject.getController().getSimulatedDate() ;
      }
   else
      {
         if ( _myObject.getController().getSimulatedDate() > _dateOfLastUse + 2 * _myObject.getController().getCyclePeriod() ) 
            { 
               cancelRegistrationToReferenceObject () ;
            }
      }

   in >> messageType ;
   typeMess = static_cast <PsnRequestType> (messageType) ;

   switch ( typeMess )
      {
      case SynchronisationMessage:
         {
            _myObject.unpack ( in ) ;
         }
         break;
      case InitialValuesMessage:
         {
            _myObject.unpackAllValues ( in ) ;
         }
         break;
      default:
         cerr<<"PsnMirrorObjectHandle::unpack: WARNING: uninterpreted message"<<endl;
         break;
      }
}



void PsnMirrorObjectHandle::extract (istream & in) 
{
   assert (false) ; //use of extract deprecated
}

//-----------------------------------------------------------------------------
void PsnMirrorObjectHandle::receiveEvent (const PsEvent & event) 
{
#ifdef _DEBUGPVMMESS
   cerr<<"PsnMirrorObjectHandle::receiveEvent (const PsEvent & event) "<<endl;
#endif
   _linkToReferencesProcess->getOutgoingBuffer () << getSimulatedObject().getObjectDescriptor ().getName ()
                                                  << EventReceived
                                                  << event ;
}



void PsnMirrorObjectHandle::receiveEvent (PsEvent * event) 
{
#ifdef _DEBUGPVMMESS
   cerr<<"PsnMirrorObjectHandle::receiveEvent (PsEvent * event) "<<endl;
#endif

   _linkToReferencesProcess->getOutgoingBuffer () << getSimulatedObject().getObjectDescriptor ().getName () 
                                                  << EventReceived
                                                  << *event ;

   delete event ;
}


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

bool PsnMirrorObjectHandle::receiveRegistrationForSignal ( const PsEventIdentifier & sigId,
                                                           const PsName & registrant, 
                                                           const PsEventIdentifier & eventId )
{

   _linkToReferencesProcess->getOutgoingBuffer ()<< getSimulatedObject().getObjectDescriptor().getName () 
                                                 << PsString ("EV") 
                                                 << (int) RegisterForSignal 
                                                 << sigId 
                                                 << registrant 
                                                 << eventId ;
   return true;
}
   
bool PsnMirrorObjectHandle::cancelRegistrationForSignal( const PsEventIdentifier & sigId , 
                                                         const PsName & registrant ) 
{
   _linkToReferencesProcess->getOutgoingBuffer () << getSimulatedObject().getObjectDescriptor().getName () << " "
                                                  << PsString ("EV") 
                                                  << (int) CancelRegistrationForSignal  
                                                  << sigId 
                                                  << registrant ;
   return true  ;
}

void PsnMirrorObjectHandle::sendEventsForSignal( PsEvent & event , const PsEventIdentifier & sigId ) 
{
   assert ( false ) ;
}

void PsnMirrorObjectHandle::sendRequestToReferenceObject (PsnRequestType typeMess) 
{
   //cerr<<"PsnMirrorObjectHandle::sendRequestToReferenceObject("<<typeMess<<")"<<endl;
   PsnPvmOutgoingMessage * sendBuffer = & _linkToReferencesProcess->getOutgoingBuffer () ;

   // as no garanty can be made on the validity of the buffer, timestamp it
   if ( typeMess == CancelRegistration )
      {
         sendBuffer->insertTimeStamp ( _myObject.getController().getSimulatedDate() + _myObject.getController().getPeriod()*1000 ) ;
      }
   // send the name of the object
   *sendBuffer << _myObject.getName ()  ;
   
   // send the request
   *sendBuffer << (int)typeMess ;
   
#ifdef _DEBGUPVMMESS
   cerr<<"PsnMirrorObjectHandle::sendRequestToReferenceObject adding "<<_myObject.getController ().getObjectDescriptor().getProcess ()<<" to the synchronisation message for object "<<_myObject.getName()<<endl;
#endif
   // send the requesting process
   *sendBuffer << _myObject.getController ().getObjectDescriptor().getProcess () ;
}

---