OMKIAttribute.h

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) 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   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
                
#if !defined OMK_IATTRIBUTE_H
#define OMK_IATTRIBUTE_H

#include "OMKEventIdentifier.h"
#include "OMKSimpleTypeT.h"
#include <string>
#include <map>
#include "OMKValuedEvent.h"

namespace OMK  
{
template< class CallerClass, class PrmType > class ValuedEventListenerCallBack ;
class ConfigurationParameterDescriptor ;
class EventListener ;
class Event ;
class InputNT ;
class OutputNT ;
namespace EventId
{





extern EventIdentifier OMK_API CURRENT_ATTRIBUTE_VALUE ;
extern EventIdentifier OMK_API getConnectToEventId( const std::string& id ) ;
extern EventIdentifier OMK_API getCurrentValueEventId( const std::string& id ) ;
extern EventIdentifier OMK_API getDisconnectEventId( const std::string& id ) ;
extern EventIdentifier OMK_API getGetValueEventId( const std::string& id ) ;
} 
  class ExtensibleSimulatedObject ;
//-----------------------------------------------------------------
class OMK_API IAttribute
{ 

protected:
  IAttribute( const Name& id ) ;
public:
  virtual ~IAttribute() ;


public:

  const ExtensibleSimulatedObject* const getOwner() const ;

private:
  friend class ExtensibleSimulatedObject ;
  void setOwner( ExtensibleSimulatedObject* owner, bool withOutput ) ;
protected:

  ExtensibleSimulatedObject* _owner ;


public:
  virtual const std::type_info& getTypeId() const = 0 ;
  virtual const std::type_info& getModelTypeId() const = 0 ;
  std::pair< std::string, std::string > getTypes() const
  {
    return std::pair< std::string, std::string >( getTypeId().name(), getModelTypeId().name() ) ;
  }
  const Name& getId() const ;
protected:
  Name _id ;


  public:
    bool isUpdated() const { return _updated ; }
    void resetUpdated() { _updated = false ; }
  protected:
    bool _updated ;


public:
  bool loadParameters( const ConfigurationParameterDescriptor * node ) 
  {
    return loadParameters( node, 0 ) ;
  }
  bool loadParameters( const ConfigurationParameterDescriptor * node, const std::string& aliasName ) 
  {
    return loadParameters( node, &aliasName ) ;
  }
protected:
  virtual bool loadParameters( const ConfigurationParameterDescriptor * node, const std::string* aliasName ) ;


public:
  virtual void createInput() = 0 ;
  virtual InputNT* getInput() = 0 ;
  virtual void createOutput() = 0 ;
  virtual OutputNT* getOutput() = 0 ;


public:
  virtual void getValueFromInput() = 0 ;
  virtual void setValueToOutput() = 0 ;


public:
  typedef std::pair< Name, Name > ConnectToPrm ;
  DECLARE_TYPE_EVENT_LISTENER( ConnectToPrm, ConnectTo, IAttribute ) ;
public:
  bool connectTo( const Name &objectName, const Name &outputName ) ;
  void disconnect() ;
protected:
  bool processConnectTo( ConnectToEvent *e ) ;
  bool processDisconnect( Event* e ) ;
  EventListener* _connectToListener ;
  EventListener* _disconnectListener ;
  const EventIdentifier _connectToId ;
  const EventIdentifier _disconnectId ;


public:
  virtual void sendIdAndValue( const Name &receiver, const EventIdentifier& eventId, const Name &attributeId ) = 0 ;
  virtual void sendValue( const Name &receiver, const EventIdentifier& eventId ) = 0 ;
  void sendValueTo( const Name &receiver, const Name& attributeId, bool genericId ) ;
  void sendValueOf( const Name &receiver, bool genericId ) ;
  virtual void fireIdAndValue( const EventIdentifier& eventId, const Name &attributeId ) = 0 ;
  virtual void fireValue( const EventIdentifier& eventId ) = 0 ;
  void fireValueTo( const Name &attributeId, bool genericId ) ;
  void fireValueOf( bool genericId ) ;
protected:
  bool processGetValue( Event* e ) ;
  EventListener* _getValueListener ;
  EventListener* _currentValueListener ;
  EventListener* _currentValueOfListener ;
  const EventIdentifier _getValueId ;
  const EventIdentifier _currentValueOfId ;


public:
  void activateConnectByEvent() ;
  void activateConnectBySignal( const Name& emitter = Name() ) ;
  void activateGetByEvent() ;
  void activateGetBySignal( const Name& emitter = Name() ) ;
  virtual void activateSetByEvent() = 0 ;
  virtual void activateSetByEventOf() = 0 ;
  void activateSetBySignal( const Name& emitter = Name() ) ;
  void activateSetBySignalOf( const Name& emitter = Name() ) ;


public:
  virtual InputNT* createInput( const Name& name ) = 0 ;
  virtual void getValueFromInput( InputNT* input ) = 0 ;
} ;
//-----------------------------------------------------------------

inline const Name& IAttribute::getId() const
{ 
  return _id ; 
}


}// namespace OMK

#endif // defined OMK_IATTRIBUTE_H

---