OMKConnectors.inl

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_III_CONNECTORS_INL
#define OMK_III_CONNECTORS_INL

// methods implementation
#include "OMKConnectors.h"
#include <algorithm>
#include "OMKExtensibleSimulatedObject.h"
#include "OMKInteractiveExtension.h"
#include "OMKIConvertor.h"
#include "OMKAttribute.inl"
#include "OMKAccessLevelList.inl"

namespace OMK  
{
  namespace Iii
  {
//========================================================================
//SimpleConnectorT
//========================================================================
//-----------------------------------------------------------------

template< typename T >
SimpleConnectorT< T >::SimpleConnectorT( const Name& id, 
                                         const Name& attributeId, 
                                         InteractiveExtension *extension,
                                         const ConfigurationParameterDescriptor* node ) 
: IConnector( id, attributeId, typeid( T ).name(), extension, node ),
  _input( 0 ),
  _attribute( extension->getOwner()->getBaseAttribute< T >( attributeId ) ),
  _convertor( 0 )
{
  OMASSERT( _attribute && "A valid interface must be set for accessor methods" ) ;
  _convertor = IConvertorT< T, T >::create( node ) ;
  OMTRACEID( OMK_DEBUG_III, "Creation in " << OMK::debugMsg( _interactiveExtension, _owner ) << " of a simple connector \"" << _id
      << "\" for the attribute \"" << attributeId << "\" category \"" << _category << "\"" ) ;
}
//-----------------------------------------------------------------
template< typename T >
SimpleConnectorT< T >::~SimpleConnectorT() 
{
  disconnect() ; 
}
//-----------------------------------------------------------------
template< typename T >
bool SimpleConnectorT< T >::isConnected( const Name& interactor ) const 
{
  return _input 
      && _input->getConnectedOutput() 
      && _input->getConnectedOutput()->getOwner().getName() == interactor ;
}
//-----------------------------------------------------------------
template< typename T >
bool SimpleConnectorT< T >::preConnect( const Name& interactor, 
                                        const OMK::Type::AccessGroupLevel& freezeLevel, 
                                        OMK::Type::AccessLevel toolLevel ) 
{ 
  // The current interactor should be informed of the new interactor
  SendControlTakenBy( interactor ) ;
  // To avoid reconnection
  disconnect() ; 
  // conditions
  OMASSERT( !_input && _toolsInUse.empty() && "The connector must be available" ) ;

  // Update of the tool list
  _toolsOnStandby.push_back( interactor ) ;
  _toolsInUse.push_back( interactor ) ;
  _accessRule->setCurrentLevel( freezeLevel, toolLevel ) ;

  return true ;
}
//-----------------------------------------------------------------
template< typename T >
bool SimpleConnectorT< T >::connect( const Name& interactor, const Name& outputName ) 
{
  bool ok = false ;
  Name inputName ;
  if( std::find( _toolsOnStandby.begin(), _toolsOnStandby.end(), interactor ) != _toolsOnStandby.end() )
  {
    // preconditions
    OMASSERT( !_input && "The connector must be disconnected" ) ;
    // creates the name's input
    inputName = interactor.getString() + outputName.getString() ;
    // creates the input in the interactive object
    _input = _attribute->createInput( inputName ) ;
    // connects it to the interactor output
    ok = _input && _input->connect( interactor, outputName ) ; 
  }
  if( ok )
  { // The interactor is no more waiting list
    _toolsOnStandby.clear() ;
  }
  else
  { // Unsuccessful connection => delete the input
    OMTRACEID( OMK_DEBUG_III, ":-( Error in SimpleConnectorT< \"" << _id 
        << "\" >:: connect for the " << OMK::debugMsg( _owner ) << std::endl
        << ">>> The interactor \"" << interactor << "\" cannot be connected !" ) ;
    _owner->deleteInput( inputName ) ;
    _input = 0 ;
  }
  return ok ;
}
//-----------------------------------------------------------------
template< typename T >
void SimpleConnectorT< T >::disconnect( const Name& interactor )
{
  if( isConnected( interactor ) )
  {
    SimpleConnectorT< T >::disconnect() ;
  }
  else
  {
    OMTRACEID( OMK_DEBUG_III, ":-( Error in SimpleConnectorT< \"" << _id.getString() 
        << "\" >:: disconnect for the " << OMK::debugMsg( _owner ) << std::endl
        << ">>> The interactor \"" << interactor.getString() << "\" is not one of those which are connected !" ) ;
  }
}
//-----------------------------------------------------------------
template< typename T >
void SimpleConnectorT< T >::disconnect()
{
  // Must send a event to inform the old interactor it was disconnected
  if( !_toolsInUse.empty() )
  {
    SendControlEnded( *_toolsInUse.begin() ) ;
  }
  if( _input )
  {
    _input->disconnect() ; 
    _owner->deleteInput( _input->getName() ) ;
    _input = 0 ;
  }
  _toolsOnStandby.clear() ; // discard the possible waiting tool
  _toolsInUse.clear() ;
  _accessRule->resetCurrentLevel() ; // unfreeze if necessary
}
//-----------------------------------------------------------------
template< typename T >
void SimpleConnectorT< T >::updateParameter() const 
{ // if it is connected, it updates the parameter
  if( _input ) 
  {
    // Update the parameter
    if( _convertor )
    { // Through the convertor
      T valueOut = _attribute->get() ;
      T valueIn ;
      _attribute->getValueFromInput( valueIn, _input ) ;
      _convertor->convert( valueOut, valueIn ) ;
      _attribute->set( valueOut ) ; 
    }
    else
    { // directly
      _attribute->getValueFromInput( _input ) ; 
    }
  }
}
//-----------------------------------------------------------------
template< typename T >
void SimpleConnectorT< T >::sendValue( const Name& receiver ) const 
{
  _attribute->sendIdAndValue( receiver, EventId::CURRENT_VALUE, _id ) ;
}
//-----------------------------------------------------------------


//========================================================================
// SharedConnectorT
//========================================================================
//-----------------------------------------------------------------
template< typename T >
SharedConnectorT< T >::SharedConnectorT( const Name& id, 
                                         const Name& attributeId, 
                                         InteractiveExtension *extension,
                                         const ConfigurationParameterDescriptor* node ) 
: IConnector( id, attributeId, typeid( T ).name(), extension, node ),
  _attribute( extension->getOwner()->getBaseAttribute< T >( attributeId ) ),
  _convertor( 0 )
{
  _convertor = IConvertorT< T, std::vector< T > >::create( node ) ;
  OMTRACEID( OMK_DEBUG_III, "Creation in " << OMK::debugMsg( _interactiveExtension, _owner ) << " of a shared connector \"" << _id
      << "\" for the attribute \"" << attributeId << "\" category \"" << _category << "\"" ) ;
}
//-----------------------------------------------------------------
template< typename T >
SharedConnectorT< T >::~SharedConnectorT() 
{ 
  disconnect() ;
  delete _convertor ;
}
//-----------------------------------------------------------------
template< typename T >
bool SharedConnectorT< T >::isConnected( const Name& interactor ) const
{
  typename MapInput::const_iterator input = _inputs.find( interactor ) ;
  return input != _inputs.end() ;
}
//-----------------------------------------------------------------
template< typename T >
bool SharedConnectorT< T >::preConnect( const Name& interactor, 
                                        const OMK::Type::AccessGroupLevel& freezeLevel, 
                                        OMK::Type::AccessLevel toolLevel ) 
{
  // The current interactor should be informed of the new interactor
  SendControlTakenBy( interactor ) ;

  // Update of the tool list
  _toolsOnStandby.push_back( interactor ) ;
  _toolsInUse.push_back( interactor ) ;
  _accessRule->setCurrentLevel( freezeLevel, toolLevel ) ;

  return true ;
}
//-----------------------------------------------------------------
template< typename T >
bool SharedConnectorT< T >::connect( const Name& interactor, const Name& outputName ) 
{
  bool ok = false ;
  Name inputName ;
  InputNT* input = 0 ;
  std::list< Name >::iterator onStandby = std::find( _toolsOnStandby.begin(), _toolsOnStandby.end(), interactor ) ;
  if( onStandby != _toolsOnStandby.end() )
  {
    // creates the name's input
    inputName = interactor.getString() + outputName.getString() ;
    // creates the input in the interactive object
    input = _attribute->createInput( inputName ) ;
    // connects it to the interactor output
    ok = input->connect( interactor, outputName ) ; 
  }
  if( ok )
  { // successful connection => add the input to the list
    _inputs.insert( std::pair< const Name, InputNT* >( interactor, input ) ) ;
    _toolsOnStandby.erase( onStandby ) ;
  }
  else
  { // Unsuccessful connection => delete the input
    OMTRACEID( OMK_DEBUG_III, ":-( Error in SharedConnectorT< \"" << _id.getString() 
        << "\" >:: connect for the " << OMK::debugMsg( _owner ) << std::endl
        << ">>> The interactor \"" << interactor.getString() << "\" cannot be connected !" ) ;
    if( !input ) 
    {
      _owner->deleteInput( inputName ) ;
    }
  }
  return ok ;
}
//-----------------------------------------------------------------
template< typename T >
void SharedConnectorT< T >::disconnect( const Name& interactor )
{
  // Only this iterator will be disconnected => find it
  std::list< Name >::iterator inUse = std::find( _toolsInUse.begin(), _toolsInUse.end(), interactor ) ;
  if( inUse != _toolsInUse.end() ) 
  {
    // Inform interactor
    SendControlReleased( interactor ) ;
    // Clean the lists => no more interactor in them
    _toolsInUse.erase( inUse ) ;
    std::list< Name >::iterator onStanby = std::find( _toolsOnStandby.begin(), _toolsOnStandby.end(), interactor ) ;
    if( onStanby != _toolsOnStandby.end() ) _toolsOnStandby.erase( onStanby ) ;
    // Informs every other interactor in use or standby
    SendControlReleasedBy( interactor ) ;
    // find the input connected to the interactor, disconnects and deletes it
    typename MapInput::iterator input = _inputs.find( interactor ) ;
    if( input != _inputs.end() )
    {
      input->second->disconnect() ; 
      _owner->deleteInput( input->second->getName() ) ;
      _inputs.erase( input ) ;
      if( _inputs.empty() ) _accessRule->resetCurrentLevel() ; // unfreeze if necessary
    }
  }
  else
  {
    OMTRACEID( OMK_DEBUG_III, ":-( Error in SharedConnectorT< \"" << _id.getString() 
             << "\" >:: disconnect for the " << OMK::debugMsg( _owner ) << std::endl
             << ">>> The interactor \"" << interactor.getString() << "\" is not one of those which are connected !" ) ;
  }
}
//-----------------------------------------------------------------
template< typename T >
void SharedConnectorT< T >::disconnect()
{
  // Inform every connected interactor
  for ( std::list< Name >::const_iterator interactor = _toolsInUse.begin() ; interactor !=  _toolsInUse.end() ; ++interactor )
  {
    SendControlEnded( *interactor ) ;
  }
  // All the iterators will be disconnected
  // disconnects and deletes all the inputs and clear the map
  for ( typename MapInput::const_iterator i = _inputs.begin() ; i !=  _inputs.end() ; ++i )
  {
    i->second->disconnect() ; 
    _owner->deleteInput( i->second->getName() ) ;
  }
  _inputs.clear() ;
  _toolsOnStandby.clear() ;
  _toolsInUse.clear() ;
  _accessRule->resetCurrentLevel() ; // unfreeze if necessary
}
//-----------------------------------------------------------------
template< typename T >
void SharedConnectorT< T >::updateParameter() const
{ 
  // if at least one input is connected, it updates the parameter
  if( _inputs.size() )
  {
    // Creating a vector with the appropriate size
    std::vector< T > values( _inputs.size() ) ;
    // Retrieve the value in the inputs
    int j = 0 ;
    for ( typename MapInput::const_iterator i = _inputs.begin() ; 
          i !=  _inputs.end() ; 
          ++i, j++ ) 
    {
      _attribute->getValueFromInput( values[j], i->second ) ;
    }
    // Update the parameter
    if( _convertor )
    {
      T valueOut = _attribute->get() ;
      _convertor->convert( valueOut, values ) ;
      _attribute->set( valueOut ) ; 
    }
  }
}
//-----------------------------------------------------------------
template< typename T >
void SharedConnectorT< T >::sendValue( const Name& receiver ) const 
{
  _attribute->sendIdAndValue( receiver, EventId::CURRENT_VALUE, _id ) ;
}
//-----------------------------------------------------------------



//========================================================================
// AssociatedConnectorT
//========================================================================

//-----------------------------------------------------------------
template< typename T >
AssociatedConnectorT< T >::AssociatedConnectorT( const Name& id, 
                                                 const Name& attributeId, 
                                                 InteractiveExtension *extension, 
                                                 const ConfigurationParameterDescriptor* node ) 
: SimpleConnectorT< T >( id, attributeId, extension, node ),
_associatedConnector( 0 )
{
}

//-----------------------------------------------------------------
template< typename T >
AssociatedConnectorT< T >::~AssociatedConnectorT() 
{
}

//-----------------------------------------------------------------
template< typename T >
bool AssociatedConnectorT< T >::preConnect( const Name& interactor, 
                                            const OMK::Type::AccessGroupLevel& freezeLevel, 
                                            OMK::Type::AccessLevel toolLevel )
{
  // Disconnect the associated connector if necessary
  if( _associatedConnector ) 
  {
    _associatedConnector->disconnect() ;
    _associatedConnector->getAccessRule().setCurrentLevel( freezeLevel, toolLevel ) ;
  }
  return SimpleConnectorT< T >::preConnect( interactor, freezeLevel, toolLevel ) ;
}

//-----------------------------------------------------------------
template< typename T >
bool AssociatedConnectorT< T >::loadParameters( const ConfigurationParameterDescriptor* node ) 
{
  // Retrieve the associated connector
  Name id ;
  ParametersAccessor::get( node, "AssociatedTo", id ) ;
  _associatedConnector = this->_interactiveExtension->getConnector( id ) ;

  return OMK::Iii::SimpleConnectorT< T >::loadParameters( node ) ;
}

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

  }// namespace Iii
}// namespace OMK

#endif // defined OMK_III_CONNECTORS_INL

---