ThreadSafeFields.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __THREAD_SAFE_FIELDS_H__
#define __THREAD_SAFE_FIELDS_H__

#include <assert.h>
#include "PeriodicUpdate.h"
#include "Threads.h"

namespace H3D {
  
  template< class BaseField >
  class ThreadSafeSField: public PeriodicUpdate< BaseField > {
  public:
    ThreadSafeSField(): rt_value_changed( false ) {}
      
    inline virtual void setValue( const typename BaseField::value_type &v,
                                  int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        rt_value = v;
        rt_value_changed = true;
      } else {
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::setValue( v, id );;
        void * param[] = { &this->value, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }

    inline virtual const typename BaseField::value_type &getValue( int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        return rt_value;
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::getValue( id );
      }
    }
    
    virtual void upToDate() {
      assert( ThreadBase::inMainThread() );
      
      if( rt_value_changed ) {
        void * param[] = { &rt_value, &this->value };
        HapticThread::synchronousHapticCB( transferValue, param );
        this->startEvent();
      } else {
        PeriodicUpdate< BaseField >::upToDate();
      }
    }

  protected:
    static PeriodicThread::CallbackCode transferValue( void * _data ) {
      void * * data = static_cast< void * * >( _data );
      typename BaseField::value_type *new_value = 
        static_cast< typename BaseField::value_type * >( data[0] );
      typename BaseField::value_type *rt_value = 
        static_cast< typename BaseField::value_type * >( data[1] );
      *rt_value = *new_value;
      return PeriodicThread::CALLBACK_DONE;
    }

    inline virtual void update() {
      assert( ThreadBase::inMainThread() );
      PeriodicUpdate< BaseField >::update();;
      void * param[] = { &this->value, &rt_value };
      HapticThread::synchronousHapticCB( transferValue, param );
    }
    
    typename BaseField::value_type rt_value;

    bool rt_value_changed;
  };
  
  template< class BaseField > 
  class ThreadSafeRefSField:  public PeriodicUpdate< BaseField > {
  public:
    ThreadSafeRefSField(): rt_value_changed( false ) {}

    inline virtual void setValue( typename BaseField::value_type v,
                                  int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        rt_value.reset( v );
        rt_value_changed = true;
      } else {
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::setValue( v, id );
        void * param[] = { v, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }

    virtual typename BaseField::typed_value_type getValue( int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        return static_cast< typename BaseField::typed_value_type >( rt_value.get() );
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::getValue( id );
      }
    }
    
    virtual void upToDate() {
      assert( ThreadBase::inMainThread() );
      
      if( rt_value_changed ) {
        void * param[] = { rt_value.get(), &this->value };
        HapticThread::synchronousHapticCB( transferValue, param );
        this->startEvent();
      } else {
        PeriodicUpdate< BaseField >::upToDate();
      }
    }

  protected:
    static PeriodicThread::CallbackCode transferValue( void * _data ) {
      void * * data = static_cast< void * * >( _data );
      typename BaseField::value_type new_value = 
        static_cast< typename BaseField::value_type >( data[0] );
      AutoRef< typename BaseField::class_type > *rt_value = 
        static_cast< AutoRef< typename BaseField::class_type> * >( data[1] );
      rt_value->reset( new_value );
      return PeriodicThread::CALLBACK_DONE;
  }

    virtual void onAdd( typename BaseField::value_type i ) {
      assert( ThreadBase::inMainThread() );
      PeriodicUpdate< BaseField >::onAdd( i );
      void * param[] = { i, &rt_value };
      HapticThread::synchronousHapticCB( transferValue, param );
    }
    
    AutoRef< typename BaseField::class_type > rt_value;

    bool rt_value_changed;
  };

  template< class BaseField >
  class ThreadSafeMField: public PeriodicUpdate< BaseField > {
  public:
    ThreadSafeMField(): rt_value_changed( false ) {}

    inline virtual void setValue( 
                 const vector< typename BaseField::value_type > &v,
                 int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        rt_value = v;
        rt_value_changed = true;
      } else {
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::setValue( v, id );
        void * param[] = { &this->value, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }

    inline virtual void setValue( typename BaseField::size_type i,
                                  const typename BaseField::value_type &t,
                                  int id = 0  ) {
      if( HapticThread::inHapticThread() ) {
        rt_value[i] = t;
        rt_value_changed = true;
      } else {
        // TODO: don't copy the entire rt_value vector, just change the current one.
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::setValue( i, t, id );
        void * param[] = { &this->value, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }

    inline virtual void swap( typename BaseField::vector_type &x, int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        rt_value.swap( x );
        rt_value_changed = true;
      } else {
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::swap( x, id );
        void * param[] = { &this->value, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }

    inline virtual void push_back( const typename BaseField::value_type &x,
                                   int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        rt_value.push_back( x );
        rt_value_changed = true;
      } else {
        // TODO: don't copy the entire rt_value vector, just change the current one.
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::push_back( x, id );
        void * param[] = { &this->value, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }

    void pop_back( int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        rt_value.pop_back();
        rt_value_changed = true;
      } else {
        // TODO: don't copy the entire rt_value vector, just change the current one.
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::pop_back( id );
        void * param[] = { &this->value, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }
    
    inline virtual void clear( int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        rt_value.clear();
        rt_value_changed = true;
      } else {
        assert( ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::clear( id );
        void * param[] = { &this->value, &rt_value };
        HapticThread::synchronousHapticCB( transferValue, param );
      }
    }

    inline virtual typename BaseField::const_iterator begin( int id = 0 ) { 
      if( HapticThread::inHapticThread() ) {
        return rt_value.begin();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::begin( id );
      }
    }
    
    inline virtual typename BaseField::const_iterator end( int id = 0 ) { 
      if( HapticThread::inHapticThread() ) {
        return rt_value.end();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::end( id );
      }
    }
    
    inline virtual typename BaseField::const_reverse_iterator rbegin( int id = 0 ) { 
      if( HapticThread::inHapticThread() ) {
        return rt_value.rbegin();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::rbegin( id );
      }
    }
    inline virtual typename BaseField::const_reverse_iterator rend( int id = 0 ) { 
      if( HapticThread::inHapticThread() ) {
        return rt_value.rend();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::rend( id );
      }
    }

    inline virtual typename BaseField::size_type size() { 
      if( HapticThread::inHapticThread() ) {
        return rt_value.size();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::size();
      }
    }

    inline virtual typename BaseField::size_type max_size() {
      if( HapticThread::inHapticThread() ) {
        return rt_value.max_size();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::max_size();
      }
    }
        
    inline virtual typename BaseField::size_type capacity() {
      if( HapticThread::inHapticThread() ) {
        return rt_value.capacity();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::capacity();
      }
    }

    inline virtual bool empty() { 
      if( HapticThread::inHapticThread() ) {
        return rt_value.empty();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::empty();
      }
    }
    inline virtual typename BaseField::const_reference operator[]( typename BaseField::size_type n ) {
      if( HapticThread::inHapticThread() ) {
        return rt_value[n];
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::operator[]( n );
      }
    }

    inline virtual typename BaseField::const_reference front( int id = 0 ) { 
      if( HapticThread::inHapticThread() ) {
        return rt_value.front();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::front( id );
      }
    }

    inline virtual typename BaseField::const_reference back( int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        return rt_value.back();
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::back( id );
      }
    }

    inline virtual const typename BaseField::vector_type &getValue( int id = 0 ) {
      if( HapticThread::inHapticThread() ) {
        return rt_value;
      } else {
        assert( ThreadBase::inMainThread() );
        return PeriodicUpdate< BaseField >::getValue( id );
      }
    }

    virtual void upToDate() {
      assert( ThreadBase::inMainThread() );
      
      if( rt_value_changed ) {
        void * param[] = { &rt_value, &this->value };
        HapticThread::synchronousHapticCB( transferValue, param );
        this->startEvent();
      } else {
        PeriodicUpdate< BaseField >::upToDate();
      }
    }

  protected:
    static PeriodicThread::CallbackCode transferValue( void * _data ) {
      void * * data = static_cast< void * * >( _data );
      typename BaseField::vector_type *new_value = 
        static_cast< typename BaseField::vector_type * >( data[0] );
      typename BaseField::vector_type *rt_value = 
        static_cast< typename BaseField::vector_type * >( data[1] );
      *rt_value = *new_value;
      return PeriodicThread::CALLBACK_DONE;
    }

    inline virtual void update() {
      assert( ThreadBase::inMainThread() );
      PeriodicUpdate< BaseField >::update();;
      void * param[] = { &this->value, &rt_value };
      HapticThread::synchronousHapticCB( transferValue, param );
    }
            
    typename BaseField::vector_type rt_value;

    bool rt_value_changed;
  };
    
}

#endif

---