OMKValuedEvent.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 OMKValuedEventHEADER
#define OMKValuedEventHEADER

#include "OMKEvent.h"
#include "OMKEventCreator.h"
#include "OMKBaseType.h" 

namespace OMK
{
template <typename UserType >
class ValuedEvent : public Event 
{
public:

  UserType value ; 
  
  ValuedEvent( const ValuedEvent & originalEvent );
  
  ValuedEvent & operator = ( const ValuedEvent & originalEvent );
  

  virtual ValuedEvent * clone() const ;

  
  virtual void insertInStream (std::ostream & = std::cout) const;

  
  virtual void extract (std::istream & = std::cin);



  virtual void unpack (IncomingSynchronisationMessage &) ;



  virtual void pack (OutgoingSynchronisationMessage &) const ;




  ValuedEvent(const EventIdentifier & event, const Date & date, const Name & sender, const Name & receiver, const UserType & userValue );
  
  ValuedEvent(const EventIdentifier & event, const Date & date, const Name & sender, const Name & receiver) ;

  
  virtual ~ValuedEvent();
  
protected:
  class ValuedEventCreator : public EventCreator
  {
  public:
    ValuedEventCreator () : EventCreator ( typeid( ValuedEvent<UserType> ).name() ) {}
    virtual ~ValuedEventCreator() {} 
  protected:
    virtual Event * createRealEvent (const EventIdentifier & event, const Date & date, const Name & sender, const Name & receiver )
    {
      return new ValuedEvent<UserType> (event, date, sender, receiver) ;
    }      
  } ;
public:
  static ValuedEventCreator myEventCreator ;
};



//------------------------ implementation -------------------------
template <typename UserType>
typename ValuedEvent<UserType>::ValuedEventCreator ValuedEvent<UserType>::myEventCreator ;


template <typename UserType>
ValuedEvent<UserType>::ValuedEvent( const ValuedEvent<UserType> & originalEvent) :
                                          Event ( originalEvent ),
                                          value ( originalEvent.value )
{
   // this static ensures that the static members are present in the genretaed code
   // enabling correct linking. In this case, it enbles valued event registration with the OMKEventCreator
  static bool instanciated = myEventCreator.touch() ;
  myEventCreator.touch(instanciated) ;
}



template <typename UserType>
ValuedEvent<UserType> & ValuedEvent<UserType>::operator = (const ValuedEvent<UserType> & originalEvent) 
{
  Event::operator = ( originalEvent ) ;
  value = originalEvent.value ;
  return *this ;
}



template <typename UserType>
ValuedEvent<UserType> * ValuedEvent<UserType>::clone () const 
{
   return new ValuedEvent<UserType>( *this ) ;
}



template <typename UserType>
void ValuedEvent<UserType>::insertInStream(std::ostream & out) const 
{
  Event::insertInStream ( out ) ;
   out<<value<<" ";
}

template <typename UserType>
void ValuedEvent<UserType>::extract ( std::istream & in ) 
{
  Event::extract ( in ) ;
   in >> value ;
}

template <typename UserType>
ValuedEvent<UserType>::ValuedEvent( const EventIdentifier & event, 
                                          const Date & date, 
                                          const Name & sender, 
                                          const Name & receiver, 
                                          const UserType & userValue ) :
   Event(event, date, sender, receiver) ,
   value (userValue )
{
   // this static ensures that the static members are present in the generated code
   // enabling correct linking. In this case, it enbles valued event registration with the OMKEventCreator
   // as from g++3, it is no longer necessary in constructors
  static bool instanciated = myEventCreator.touch() ;
  myEventCreator.touch(instanciated) ;
}



template <typename UserType>
ValuedEvent<UserType>::ValuedEvent( const EventIdentifier & event, 
                                          const Date & date, 
                                          const Name & sender, 
                                          const Name & receiver ) :
Event(event, date, sender, receiver) 
{
   // this static ensures that the static members are present in the generated code
   // enabling correct linking. In this case, it enbles valued event registration with the OMKEventCreator
   // as from g++3, it is no longer necessary in constructors
  static bool instanciated = myEventCreator.touch() ;
  myEventCreator.touch(instanciated) ;
}


template <typename UserType>
ValuedEvent<UserType>::~ValuedEvent() 
{
   // this static ensures that the static members are present in the generated code
   // enabling correct linking. In this case, it enbles valued event registration with the OMKEventCreator
   static bool instanciated = myEventCreator.touch() ;  
  myEventCreator.touch(instanciated) ;
}

template <typename UserType>
void ValuedEvent<UserType>::unpack (IncomingSynchronisationMessage & in)
{
   //un pack base information
  Event::unpack ( in ) ;
   in >> value ;
}

template< typename UserType >
void ValuedEvent< UserType >::pack( OutgoingSynchronisationMessage & out ) const
{
   static Name valueType( typeid( ValuedEvent< UserType > ).name() ) ;
   out << valueType
       << eventId 
       << date 
       << sender 
       << receiver
       << value ;
}

} // namespace OMK

#endif

---