---

PsOutputAlias.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 PsOutputAliasHEADER
#define PsOutputAliasHEADER

#include <PsOutput.h>
//-----------------------------------------------------------------
//-----------------------------------------------------------------
/* An output alias
 * aliases are use to shared an output between an object and it's sons in the simulation tree
 * @author Olivier Filangi (version 1.0)
 * @version 1.3 (revision $revision$ )
 * \li 1.0 -> 1.1 by David Margery: english version of an alias
 * \li 1.1 -> 1.2 by David Margery: changed support for aliases of aliases : reponsability for correct alias linking is now responsability of this class
 * \li 1.2 -> 1.3 by David Margery (2002/06/04): added support for virtual inheritance of PsAttribute
 */

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

   virtual ~PsOutputAlias ();


   virtual void unsetAlias () ;

   virtual void setUsedOutput (PsOutput<Type> * output) ;

   virtual void unalias() ;

   virtual void aliasedOutputDeleted () ;

   virtual void alias(PsOutput<Type> * aliasedOutput);

protected:
   virtual void notifyConnectedSensitiveInputs();

   PsOutput<Type> * _aliasedOutput ;

}; // PsOutputAlias

template <typename Type>
inline PsOutputAlias<Type>::PsOutputAlias ( const PsName & aliasName,
                                            PsSimulatedObject & owner,
                                            PsOutput<Type> * aliasedOutput,
                                            int historyLength,
                                            PsPolatorNT * polator ) 
   :
   PsAttribute( owner, aliasName),
   PsOutput<Type>(aliasName, owner, historyLength, polator),
   _aliasedOutput ( aliasedOutput )
{

   assert ( aliasedOutput != NULL ) ;
   
   aliasedOutput->setAlias ( this ) ;

   aliasedOutput->setUsedOutput(this) ;
         
}


template <class Type>
inline PsOutputAlias<Type>::~PsOutputAlias ()
{
  unalias();
}


template <class Type>
void PsOutputAlias<Type>::setUsedOutput (PsOutput<Type> * output)
{
   PsOutput<Type>::setUsedOutput( output ) ;
   
   if ( _aliasedOutput != NULL )
      {
         _aliasedOutput->setUsedOutput( output ) ;
      }
}

template <typename Type>
void PsOutputAlias<Type>::notifyConnectedSensitiveInputs() 
{
   PsOutput<Type>::notifyConnectedSensitiveInputs() ;
   if ( _aliasedOutput != NULL )
      {
         _aliasedOutput->notifyConnectedSensitiveInputs() ;
      }
}

template <typename Type>
inline void PsOutputAlias<Type>::unalias()
{
   if ( _aliasedOutput != NULL ) 
      {
         _aliasedOutput->unsetAlias() ;
         setUsedOutput ( this ) ;
         _aliasedOutput = NULL ;
      }
}


template <typename Type> 
inline void PsOutputAlias<Type>::unsetAlias()
{
  PsOutput<Type>::unsetAlias () ;
} 


template <typename Type>
inline void PsOutputAlias<Type>::alias(PsOutput<Type> * aliasedOutput)
{
   assert ( aliasedOutput != NULL ) ;
   
   if ( _aliasedOutput != NULL )
      {
         unalias() ;
         _aliasedOutput = aliasedOutput ;
      }

   aliasedOutput->setAlias ( this ) ;

   aliasedOutput->setUsedOutput(this) ;
}

template <typename Type>
inline void PsOutputAlias<Type>::aliasedOutputDeleted () 
{
   _aliasedOutput = NULL ;
}

#endif

---