E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeCommunicator.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright © 2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef TECOMMUNICATOR_H
  #define TECOMMUNICATOR_H
  
  #include "TeMutex.h"
  #include "TeAgnostic.h"

  #include <list>
  #include <algorithm>
  
  #define TECOMMWRAPPER( function_name, param_type, class_name ) \
    protected : void function_name( const param_type& x ); \
    public : static void function_name( const param_type& x, void* objptr ) \
    { \
      class_name * casted_ptr = ( class_name * ) objptr; \
      casted_ptr->function_name( x ); \
    };
    
  template< typename DataType >
  class TeCommunicator 
  {
    public :
    
      typedef void (*WrapperFuncPtrT)( const DataType&, void* );
            
      TeCommunicator( void* host_obj_ptr = 0,
        WrapperFuncPtrT wrapper_func_ptr = 0,
        bool enabled_flag = true );

      ~TeCommunicator();
      
      void setHostObj( void* host_obj_ptr = 0, 
        WrapperFuncPtrT wrapper_func_ptr = 0 );
      
      bool connect( TeCommunicator< DataType>& external );
      
      void disconnect();
      
      void disconnect( TeCommunicator< DataType>& external );
      
      void send( const DataType& data ) const;
      
      void toggle( bool enabled_flag );      
      
      bool isEnabled();          
      
    protected :
      
      typedef TeCommunicator< DataType >* ComPtrT;
      
      typedef std::list< ComPtrT > ContainerT;
      
      typedef typename ContainerT::iterator ContItT;      
      
      void ConnectMe( ComPtrT my_pointer );
      
      void DisconnectMe( ComPtrT my_pointer );
      
      inline void Receive( const DataType& data ) const; 
      
    private :
    
      bool emission_reception_enabled_;
    
      WrapperFuncPtrT wrapper_func_ptr_;
      
      void* host_obj_ptr_;
      
      mutable ContainerT connections_;
      
      mutable TeMutex lock_instance_;      
      
      TeCommunicator( const TeCommunicator< DataType >& ) {};
      
      const TeCommunicator< DataType >& operator=( 
        const TeCommunicator< DataType >& ) {};
      
  };
  

  template< typename DataType >  
  TeCommunicator< DataType >::TeCommunicator( void* host_obj_ptr,
    WrapperFuncPtrT wrapper_func_ptr, bool enabled_flag )
  {
    wrapper_func_ptr_ = 0;
    host_obj_ptr_ = 0;
    emission_reception_enabled_ = enabled_flag;
    
    setHostObj( host_obj_ptr, wrapper_func_ptr );
  }
  
  
  template< typename DataType >  
  TeCommunicator< DataType >::~TeCommunicator()
  {
    disconnect();
  }
  
  
  template< typename DataType >  
  void TeCommunicator< DataType >::setHostObj( void* host_obj_ptr,
    WrapperFuncPtrT wrapper_func_ptr )
  {
    lock_instance_.lock();
    
//   TEAGN_TRUE_OR_THROW( (wrapper_func_ptr != 0), 
//      ( ( wrapper_func_ptr == 0 ) && ( host_obj_ptr == 0 ) ) || 
//      ( ( wrapper_func_ptr != 0 ) && ( host_obj_ptr != 0 ) ) ), 
//      "Invalid receiver_func_ptr/host_obj_ptr parameters" );
      
    wrapper_func_ptr_ = wrapper_func_ptr;
    host_obj_ptr_ = host_obj_ptr;
    
    lock_instance_.unLock();
  }
  
  
  template< typename DataType >
  bool TeCommunicator< DataType >::connect( 
    TeCommunicator< DataType>& external )
  {
    lock_instance_.lock();
    
//    if( ( wrapper_func_ptr_ == 0 ) || ( host_obj_ptr_ == 0 ) ) {
             if( wrapper_func_ptr_ == 0 ) {
      lock_instance_.unLock();
      
      TEAGN_LOGERR( "Connecting a inactive communicator instance" );
      
      return false;
    }
    
    ContItT it = find( connections_.begin(), connections_.end(),
      &external );

    if( it == connections_.end() ) {
      connections_.push_back( &external );
      external.ConnectMe( this );
    }
    
    lock_instance_.unLock();
    
    return true;
  }
  

  template< typename DataType >
  void TeCommunicator< DataType >::disconnect()
  {
    lock_instance_.lock();
    
    ContItT it = connections_.begin();
    ContItT it_end = connections_.end();

    while( it != it_end ) {
      (*it)->DisconnectMe( this );
      
      ++it;
    }
    
    connections_.clear();
    
    lock_instance_.unLock();
  }
  
  
  template< typename DataType >
  void TeCommunicator< DataType >::disconnect( 
    TeCommunicator< DataType>& external )
  {
    lock_instance_.lock();
    
    ContItT it = find( connections_.begin(), connections_.end(),
      &external );
      
    if( it != connections_.end() ) {
      (*it)->DisconnectMe( this );
      connections_.erase( it );
    }
    
    lock_instance_.unLock();
  }

  
  template< typename DataType >
  void TeCommunicator< DataType >::ConnectMe( 
    ComPtrT my_pointer )
  {
    lock_instance_.lock();
    
    ContItT it = find( connections_.begin(), connections_.end(),
      my_pointer );
      
    if( it == connections_.end() ) {
      connections_.push_back( my_pointer );
    }
    
    lock_instance_.unLock();
  }

  
  template< typename DataType >
  void TeCommunicator< DataType >::DisconnectMe( 
    ComPtrT my_pointer )
  {
    lock_instance_.lock();
    
    ContItT it = find( connections_.begin(), connections_.end(),
      my_pointer );
      
    if( it != connections_.end() ) {
      connections_.erase( it );
    }
    
    lock_instance_.unLock();
  }
  
  
  template< typename DataType >
  void  TeCommunicator< DataType >::send( const DataType& data ) const
  {
    if( emission_reception_enabled_ )
    {
      lock_instance_.lock();
      
      ContItT it = connections_.begin();
      ContItT it_end = connections_.end();
      
      while( it != it_end ) {
        (*it)->Receive( data );
        
        ++it;  
      }
      
      lock_instance_.unLock();
    }
  }
  
  
  template< typename DataType >
  void  TeCommunicator< DataType >::toggle( bool enabled_flag )
  {
    emission_reception_enabled_ = enabled_flag;
  }
  
  
  template< typename DataType >
  bool TeCommunicator< DataType >::isEnabled()
  {
    return emission_reception_enabled_;
  }  

  
  template< typename DataType >
  inline void  TeCommunicator< DataType >::Receive( 
    const DataType& data ) const
  {
    if( emission_reception_enabled_ && ( wrapper_func_ptr_ != 0 ) ) 
    {
      lock_instance_.lock();
      
      wrapper_func_ptr_( data, host_obj_ptr_ );
      
      lock_instance_.unLock();
    }
  }
    
#endif