OMKAttribute.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_ATTRIBUTE_H
#define OMK_ATTRIBUTE_H

#include "OMKIAttribute.h"
#include "OMKIAccessor.h"
#include "OMKSimpleTypeT.h"
#include "OMKEventTypeForAttributeT.h"

namespace OMK  
{
template< typename T > class Output ;
template< typename T > class Input ;


//-----------------------------------------------------------------
  template< typename PrmType >
class IAttributeBaseT : public IAttribute, public IAccessorT< PrmType >
{ 

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


public:
  virtual IAccessorT< PrmType >* getAccessor() { return  this ; }
  virtual const std::type_info& getTypeId() const { return typeid( PrmType ) ; }


public:
  using IAttribute::loadParameters ;
protected:
  virtual bool loadParameters( const ConfigurationParameterDescriptor * node, const std::string* aliasName ) ;


public:
  virtual void getValueFromInput( PrmType& value, InputNT* input,       int deltaT = 0 ) const = 0 ;
  virtual void getValueFromInput( InputNT* input ) = 0 ;
} ;

//-----------------------------------------------------------------
template< typename PrmType, typename ModelType, typename AccessorType >
class IAttributeT : public IAttributeBaseT< PrmType >, public EventTypeForAttributeT< ModelType >
{ 
public:
  typedef std::pair< Name, ModelType > IdAndValuePrm ;
  DECLARE_TYPE_EVENT_LISTENER( IdAndValuePrm, IdAndValue, EventTypeForAttributeT< ModelType > ) ;
  using IAttributeBaseT< PrmType >::getId ;

protected:
  IAttributeT( const Name& id, const AccessorType& init ) ;
public:
  virtual ~IAttributeT() ;


public:
  using IAttribute::isUpdated ;
  using IAttribute::_updated ;
  virtual const std::type_info& getModelTypeId() const { return typeid( ModelType ) ; }
  virtual const PrmType& get() const 
  {
    return _accessor.AccessorType::get() ; 
  }
  virtual void set( const PrmType& value )
  {
    this->_updated = true ;
    _accessor.AccessorType::set( value ) ; 
  }
protected:
  AccessorType _accessor ;


public:
  virtual void createInput() ;
  virtual InputNT* getInput() ;
  Input< ModelType >* getInputT() ;
  virtual void createOutput() ;
  virtual OutputNT* getOutput() ;
  Output< ModelType >* getOutputT() ;
protected:
  Input< ModelType >* _input ;
  Output< ModelType >* _output ;


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


public:
  virtual void sendIdAndValue( const Name &receiver, const EventIdentifier& eventId, const Name &attributeId ) ;
  virtual void sendValue( const Name &receiver, const EventIdentifier& eventId ) ;
  virtual void fireIdAndValue( const EventIdentifier& eventId, const Name &attributeId ) ;
  virtual void fireValue( const EventIdentifier& eventId ) ;
protected:
  bool processSetValueOf( ValuedEvent< ModelType > *e ) ;
  virtual bool processSetValue( IdAndValueEvent *e ) ;


public:
  virtual void activateSetByEvent() ;
  virtual void activateSetByEventOf() ;


public:
  virtual InputNT* createInput( const Name& name ) ;
  virtual void getValueFromInput( InputNT* input ) ;
  virtual void getValueFromInput( PrmType& value, InputNT* input, int deltaT = 0 ) const ;
} ;

//-----------------------------------------------------------------
template< typename PrmType >
class AttributeT : public IAttributeT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorT< PrmType > >
{ 

public:
  AttributeT( const Name& id, const PrmType& value ) 
    : IAttributeT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorT< PrmType > >( id, AccessorT< PrmType >( value ) ) {}
  virtual ~AttributeT() {}









  PrmType& getRef() { return this->_accessor.operator PrmType&() ; }
} ;

//-----------------------------------------------------------------
template< typename PrmType >
class AttributeTypeT : public IAttributeT< PrmType, PrmType, AccessorT< PrmType > >
{ 

public:
  AttributeTypeT( const Name& id, const PrmType& value ) 
    : IAttributeT< PrmType, PrmType, AccessorT< PrmType > >( id, AccessorT< PrmType >( value ) ) {}
  virtual ~AttributeTypeT() {}

  PrmType& getRef() { return this->_accessor.operator PrmType&() ; }
} ;


//-----------------------------------------------------------------
template< typename PrmType, typename  PrmAccType >
class AttributeAccT : public IAttributeT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorAccT< PrmType,  PrmAccType > >
{ 

public:
  AttributeAccT( const Name& id, IAccessorT<  PrmAccType >* accessor ) 
    : IAttributeT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorAccT< PrmType,  PrmAccType > >( id, AccessorAccT< PrmType,  PrmAccType >( accessor ) ) {}
  virtual ~AttributeAccT() {}







  void setAccessor( IAccessorT< PrmAccType >* accessor )
  {
    this->_accessor.setAccessor( accessor ) ;
  }
} ;

//-----------------------------------------------------------------
template< typename PrmType, typename  PrmAccType >
class AttributeAccTypeT : public IAttributeT< PrmType, PrmType, AccessorAccT< PrmType,  PrmAccType > >
{ 

public:
  AttributeAccTypeT( const Name& id, IAccessorT<  PrmAccType >* accessor ) 
    : IAttributeT< PrmType, PrmType, AccessorAccT< PrmType,  PrmAccType > >( id, AccessorAccT< PrmType,  PrmAccType >( accessor ) ) {}
  virtual ~AttributeAccTypeT() {}







  void setAccessor( IAccessorT< PrmAccType >* accessor )
  {
    this->_accessor.setAccessor( accessor ) ;
  }
} ;



//-----------------------------------------------------------------
template< typename PrmType, typename ObjectType >
class AttributeFctT : public IAttributeT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorFctT< PrmType, ObjectType > >
{ 

public:
  AttributeFctT( const Name& id, ObjectType *object, 
                 typename AccessorFctT< PrmType, ObjectType >::SetMethod setMethod, 
                 typename AccessorFctT< PrmType, ObjectType >::GetMethod getMethod ) 
    : IAttributeT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorFctT< PrmType, ObjectType > >
    ( id, AccessorAccT< PrmType, ObjectType >( object, setMethod, getMethod ) ) {}
  virtual ~AttributeFctT() {}
} ;

//-----------------------------------------------------------------
template< typename PrmType, typename ObjectType >
class AttributeFctTypeT : public IAttributeT< PrmType, PrmType, AccessorFctT< PrmType, ObjectType > >
{ 

public:
  AttributeFctTypeT( const Name& id, ObjectType *object, 
                     typename AccessorFctT< PrmType, ObjectType >::SetMethod setMethod, 
                     typename AccessorFctT< PrmType, ObjectType >::GetMethod getMethod ) 
    : IAttributeT< PrmType, PrmType, AccessorFctT< PrmType, ObjectType > >
    ( id, AccessorAccT< PrmType, ObjectType >( object, setMethod, getMethod ) ) {}
  virtual ~AttributeFctTypeT() {}
} ;


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

}// namespace OMK

#include "OMKAttribute.inl"

#endif // defined OMK_ATTRIBUTE_H

---