OMKInteractiveExtension.cpp

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                                 */
/************************************************************************/
                
#include "OMKInteractiveExtension.h"
#include "OMKValuedEventListenerCallBack.h"
#include "OMKEventListenerCallBack.h"
#include "OMKParametersAccessor.inl"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKIAttribute.h"
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include "OMKAccessLevelList.inl"

using namespace OMK ;
using namespace OMK::Iii ;
using namespace OMK::Type ;

REGISTER_EXTENSION_FACTORY( InteractiveExtension, "Interactive" ) ;
//-----------------------------------------------------------------
// Default constructor
InteractiveExtension::InteractiveExtension( ExtensibleSimulatedObject* owner, const Name& id, bool registerExtension )
: ExtensionT< ExtensibleSimulatedObject >( owner, id, registerExtension ),
  _getAccessibleParametersListener( 0 ),
  _controlTakeOverAndGetCurrentValuesListener( 0 ),
  _controlReleaseListener( 0 ),
  _controlFreezeListener( 0 ),
  _controlUnfreezeListener( 0 ),
  _getCurrentValuesListener( 0 ),
  _newValueAvailableListener( 0 ),
  _defaultAccessRule( 0 )
{
}

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

// Destructor
InteractiveExtension::~InteractiveExtension()
{
  // Destroy each connector, which will disconnect its associated input
  for ( ConnectorsMap::const_iterator i = _connectors.begin() ; i !=  _connectors.end() ; ++i )
  {
    delete i->second ;
  }
  // Finally clears the map 
  _connectors.clear() ;
  _preConnectors.clear() ;
  _postConnectors.clear() ;

  //Removes event listener
  delete _getAccessibleParametersListener ;
  delete _controlTakeOverAndGetCurrentValuesListener ;
  delete _controlReleaseListener ;
  delete _controlFreezeListener ;
  delete _controlUnfreezeListener ;
  delete _getCurrentValuesListener ;
  delete _newValueAvailableListener ;
}
//-----------------------------------------------------------------

bool InteractiveExtension::loadExtensionParameters( const ConfigurationParameterDescriptor * node ) 
{
  // Creates the event listeners
  _getAccessibleParametersListener = new GetAccessibleParametersEventListener
        ( *_owner, this, 
        &InteractiveExtension::processGetAccessibleParameters, 
        EventId::GET_ACCESSIBLE_PARAMETERS ) ;
  _controlTakeOverAndGetCurrentValuesListener = new TakeOverAndGetCurrentValuesEventListener
        ( *_owner, this, 
        &InteractiveExtension::processControlTakeOverAndGetCurrentValues,
        EventId::CONTROL_TAKE_OVER_AND_GET_CURRENT_VALUES ) ;
  _controlReleaseListener = new EventListenerCallBack< InteractiveExtension >
        ( *_owner, this, 
        &InteractiveExtension::processControlRelease,
        EventId::CONTROL_RELEASE ) ;
  _controlFreezeListener = new ControlFreezeEventListener
        ( *_owner, this, 
        &InteractiveExtension::processControlFreeze,
        EventId::CONTROL_FREEZE ) ;
  _controlUnfreezeListener = new EventListenerCallBack< InteractiveExtension >
        ( *_owner, this, 
        &InteractiveExtension::processControlUnfreeze,
        EventId::CONTROL_UNFREEZE ) ;
  _getCurrentValuesListener = new GetCurrentValuesEventListener
        ( *_owner, this, 
        &InteractiveExtension::processGetCurrentValues, 
        EventId::GET_CURRENT_VALUES ) ;
  _newValueAvailableListener = new NewValueAvailableEventListener
        ( *_owner, this, 
        &InteractiveExtension::processNewValueAvailable, 
        EventId::NEW_VALUE_AVAILABLE ) ;

  // Retrieve the connector fields to create the connectors which defined a "Class"
  const ConfigurationParameterDescriptor * connectorsNode = node ? node->getSubDescriptorByName( "Connectors" ) : 0 ;

  if( connectorsNode )
  {
    // Create the connectors
    int nbItems = connectorsNode->getNumberOfSubItems() ;
    for( int i = 0 ; i < nbItems ; ++i )
    { 
      // Retrieves parameters sets for each extension
      Name id( static_cast<const MultipleConfigurationParameter *>( connectorsNode )->getNameOfSubDescriptor( i ) ) ;
      const ConfigurationParameterDescriptor * connectorParameters = connectorsNode->getSubDescriptorByPosition( i ) ;
      // Try to retrieve the class id to create the extension
      Name attributeId( id ) ;
      ParametersAccessor::get( connectorParameters, "Attribute", attributeId ) ;
      std::string classIdTmp ;
      if( ParametersAccessor::get( connectorParameters, "Type", classIdTmp ) )
      {
        IAttribute *foundAttribute = _owner->getAttribute( attributeId ) ;
        if( foundAttribute == 0 )
        {
          OMFATALERROR( "Attribute ID [" << attributeId
                        << "] not found in code for the connector of extension with ID ["
                        << getId() << "]" ) ;
        }
        // Now ClassId is ok => Create the extension
        Name classId( classIdTmp + "ConnectorT" + foundAttribute->getTypeId().name() ) ;
        ConnectorFactory::getInstance().create( classId )( id, attributeId,
                                                           this, connectorParameters ) ;
      }
      else if( ParametersAccessor::get( connectorParameters, "Class", classIdTmp ) )
      { // ClassId is ok => Create the extension
        Name classId( classIdTmp + _owner->getAttribute( attributeId )->getTypeId().name() ) ;
        ConnectorFactory::getInstance().create( classId )( id, attributeId,
                                                           this, connectorParameters ) ;
      }
      else
      {
        OMERROR( "Unable to create the connector for the extension with ID [" << getId()
                 << "] due to errors in configuration file" ) ;
      }
    }
    // Initialise the connector
    for( ConnectorsMap::iterator connector = _connectors.begin() ; 
         connector != _connectors.end() ; 
         ++connector )
    {
      connector->second->loadParameters( connectorsNode->getSubDescriptorByName( connector->second->id().getCString() )  ) ;
    }
  }
  return true ;
}
//-----------------------------------------------------------------
void InteractiveExtension::addConnector( IConnector* connector, bool postComputing ) 
{
  _connectors.insert( std::pair< const Name, IConnector* >( connector->id(), connector ) ) ;

  if( postComputing ) 
  {
    _postConnectors.insert( std::pair< const Name, IConnector* >( connector->id(), connector ) ) ;
  }
  else
  {
    _preConnectors.insert( std::pair< const Name, IConnector* >( connector->id(), connector ) ) ;
  }
}
 
//-----------------------------------------------------------------
IConnector* InteractiveExtension::getConnector( const Name& id ) 
{
  ConnectorsMap::iterator connector = _connectors.find( id ) ;
  return connector != _connectors.end() ? connector->second : 0 ;
}

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

void InteractiveExtension::preComputeParameters()
{
  // Update the interactive parameters 
  for( ConnectorsMap::iterator i = _preConnectors.begin() ; i !=  _preConnectors.end() ; ++i )
  {
    (*i).second->updateParameter() ;
  }
}
//-----------------------------------------------------------------

void InteractiveExtension::postComputeParameters()
{
  // Update the interactive parameters 
  for( ConnectorsMap::iterator i = _postConnectors.begin() ; i !=  _postConnectors.end() ; ++i )
  {
    (*i).second->updateParameter() ;
  }
}

//-----------------------------------------------------------------
bool InteractiveExtension::processGetAccessibleParameters( GetAccessibleParametersEvent *event ) 
{
  OMASSERTM( event->eventId == EventId::GET_ACCESSIBLE_PARAMETERS, "The event must be \"connector parameters ?\"" ) ;
  AccessibleParametersListPrm connectorsList ;
  for( ConnectorsMap::const_iterator i = _connectors.begin() ; i !=  _connectors.end() ; ++i )
  {
    connectorsList.push_back( AccessibleParameterPrm( i->second, event->value.getValue() ) ) ;
  }
  _owner->sendValuedEvent( event->sender, EventId::ACCESSIBLE_PARAMETERS, AccessibleParametersListType( connectorsList ) ) ;

  return true ;
}

//-----------------------------------------------------------------
bool InteractiveExtension::processGetCurrentValues( GetCurrentValuesEvent *event ) 
{
  // Establishes the specified connections
  const GetCurrentValuesPrm& value = event->value.getValue() ;
  for( GetCurrentValuesPrm::ItemsList::const_iterator prm = value._items.begin() ;
       prm != value._items.end() ; 
       ++prm )
  { // Try to connect each id sent by the interactor 
    // Is the id in the connector list
    ConnectorsMap::iterator connector = _connectors.find( *prm ) ;
    if( connector != _connectors.end() 
     && connector->second->getAccessRule().isAccessGranted( value._level, event->sender ) )
    { // send value
      connector->second->sendValue( event->sender ) ;
    }
    else
    { // Fails to find the values
      OMTRACEID( OMK_DEBUG_III, ":-( Error for the " << OMK::debugMsg( _owner ) << std::endl
          << ">>> \"" << event->sender << "\" cannot get \"" << *prm << "\" value" << std::endl
          << ( connector == _connectors.end() 
              ? ">>> because => the connector does not exist ! "
              : ">>> because => the connector not currently accessible ! " ) ) ;
    }
  }
  _owner->sendEvent( event->sender, EventId::CURRENT_VALUES_SENT ) ;

  return true ;
}

//-----------------------------------------------------------------
bool InteractiveExtension::processControlTakeOverAndGetCurrentValues( TakeOverAndGetCurrentValuesEvent *event ) 
{
  const TakeOverAndGetCurrentValuesPrm& value = event->value.getValue() ;
  ControlTakenPrm takenConnectors ;
  for( TakeOverAndGetCurrentValuesPrm::ItemsList::const_iterator prm = value._items.begin() ;
       prm != value._items.end() ; 
       ++prm )
  { // Try to connect each id sent by the interactor 
    // Is the id in the connector list
    ConnectorsMap::iterator connector = _connectors.find( prm->_id ) ;
    if( connector != _connectors.end() 
     && connector->second->getAccessRule().isAccessGranted( value._level, event->sender )
     && connector->second->preConnect( event->sender, prm->_accessGroup, value._level ))
    { // Connection
      connector->second->sendValue( event->sender ) ;
      connector->second->getAccessRule().setCurrentLevel( prm->_accessGroup, value._level ) ;
      takenConnectors.push_back( ControlTakenOfParameterPrm( prm->_id, connector->second->getToolsInUse() ) ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_III, ":-( Error in InteractiveExtension::processControlTakeOver for the " << OMK::debugMsg( _owner ) << std::endl
          << ">>> \"" << event->sender << "\" cannot control \"" << prm->_id << "\" with \"" << prm->_secondId << "\"" << std::endl
          << ( connector == _connectors.end()  
               ? ">>> because the connector does not exist ! "
               : ">>> because the connector is not currently accessible ! " ) ) ;
    }
  }
  _owner->sendValuedEvent( event->sender, EventId::CURRENT_VALUES_SENT_AND_CONTROL_TAKEN, ControlTakenType( takenConnectors ) ) ;

  return true ;
}
//-----------------------------------------------------------------
bool InteractiveExtension::processNewValueAvailable( NewValueAvailableEvent *event ) 
{
  // Establishes the specified connections
  const NewValueAvailablePrm& prm = event->value ;
  ConnectorsMap::iterator connector = _connectors.find( prm.first ) ;
  std::list< Name >* toolsInUse = connector != _connectors.end() ? &connector->second->getToolsInUse() : 0 ;
  if( toolsInUse
    && std::find( toolsInUse->begin(), toolsInUse->end(), event->sender ) != toolsInUse->end() )
  {
    connector->second->connect( event->sender, prm.second ) ;
  }
  else
  {
    OMTRACEID( OMK_DEBUG_III, ":-( Error in InteractiveExtension::processControlTakeOver for the " << OMK::debugMsg( _owner ) << std::endl
        << ">>> \"" << event->sender << "\" cannot connect \"" << prm.first << "\" with \"" << prm.second << "\"" << std::endl
        << ">>> because " << ( toolsInUse ? "" : "the connector does not exist ! " )
        << ( toolsInUse && std::find( toolsInUse->begin(), toolsInUse->end(), event->sender ) != toolsInUse->end() ? "" : "the connector is not available ! " ) ) ;
  }
  return true ;
}
//-----------------------------------------------------------------
bool InteractiveExtension::processControlRelease( Event *event ) 
{
  ControlReleaseEvent* valuedEvent = dynamic_cast< ControlReleaseEvent* >( event ) ;
  if( valuedEvent )
  { // Removes the specified connections
    const ControlReleasePrm& value = valuedEvent->value.getValue() ;
    for ( ControlReleasePrm::const_iterator id = value.begin() ; id != value.end() ; ++id )
    { // Try to release each id sent by the interactor 
      // Is the id in the connector list
      ConnectorsMap::iterator connector = _connectors.find( *id ) ;
      if( connector != _connectors.end() && connector->second->isConnected( event->sender ) )
      { // Disconnection
        connector->second->disconnect( event->sender ) ;
      }
      else
      {
        OMTRACEID( OMK_DEBUG_III, ":-( Error in InteractiveExtension::processControlRelease for the " << OMK::debugMsg( _owner ) << std::endl
                << ">>> Unable to disconnect \"" << event->sender << "\" from \"" << *id << "\" because "
                << ( connector == _connectors.end() ? "the connector doesn't exist":"the interactor is not connected to the connector") << std::endl ) ;
      }
    }
  }
  else
  { // Removes all connections from this interactor
    for ( ConnectorsMap::const_iterator connector = _connectors.begin() ; connector != _connectors.end() ; ++connector )
    {
      if( connector->second->isConnected( event->sender ) )
      {
        connector->second->disconnect( event->sender ) ;
      }
    }
  }
  // Even if the disconnection has failed, the message is processed
  return true ;
}

//-----------------------------------------------------------------
bool InteractiveExtension::processControlFreeze( ControlFreezeEvent *event ) 
{
  // Change the access level of the specified connections
  const ControlFreezePrm& value = event->value.getValue() ;
  for ( ControlFreezePrm::ItemsList::const_iterator id = value._items.begin() ; id != value._items.end() ; ++id )
  { // Try to release each id sent by the interactor 
    // Is the id in the connector list
    ConnectorsMap::iterator connector = _connectors.find( id->first ) ;
    if( connector != _connectors.end() 
     && connector->second->isConnected( event->sender ) )
    { // Change current access level
      connector->second->getAccessRule().setCurrentLevel( id->second, value._level ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_III, ":-( Error in InteractiveExtension::processControlFreeze for the " << OMK::debugMsg( _owner ) << std::endl
          << ">>> Unable to freeze \"" << event->sender << "\" from \"" << *id << "\" because "
          << ( connector == _connectors.end() ? 
          "the connector doesn't exist" : "the interactor is not connected to the connector" ) << std::endl ) ;
    }
  }
  // Even if the action has failed, the message is processed
  return true ;
}

//-----------------------------------------------------------------
bool InteractiveExtension::processControlUnfreeze( Event *event ) 
{
  ControlUnfreezeEvent* valuedEvent = dynamic_cast< ControlUnfreezeEvent* >( event ) ;
  if( valuedEvent )
  { // Unfreezes the specified connections
    const ControlUnfreezePrm& value = valuedEvent->value.getValue() ;
    for ( ControlUnfreezePrm::const_iterator id = value.begin() ; id != value.end() ; ++id )
    { // Try to release each id sent by the interactor 
      // Is the id in the connector list
      ConnectorsMap::iterator connector = _connectors.find( *id ) ;
      if( connector != _connectors.end() && connector->second->isConnected( event->sender ) )
      { // Change current access level
        connector->second->getAccessRule().resetCurrentLevel() ;
      }
      else
      {
        OMTRACEID( OMK_DEBUG_III, ":-( Error in InteractiveExtension::processControlUnfreeze for the " << OMK::debugMsg( _owner ) << std::endl
            << ">>> Unable to unfreeze \"" << event->sender << "\" from \"" << *id << "\" because "
            << ( connector == _connectors.end() ? "the connector doesn't exist":"the interactor is not connected to the connector") << std::endl ) ;
      }
    }
  }
  else
  { // Removes all connections from this interactor
    for ( ConnectorsMap::const_iterator connector = _connectors.begin() ; connector != _connectors.end() ; ++connector )
    {
      if( connector->second->isConnected( event->sender ) )
      {
//        connector->second->getAccessRule().unfreeze() ;
      }
    }
  }
  // Even if the disconnection has failed, the message is processed
  return true ;
}

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

---