H3D API  2.4.1
ThreadSafeFields.h
Go to the documentation of this file.
1 // Copyright 2004-2019, SenseGraphics AB
3 //
4 // This file is part of H3D API.
5 //
6 // H3D API is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 2 of the License, or
9 // (at your option) any later version.
10 //
11 // H3D API is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License
17 // along with H3D API; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 //
20 // A commercial license is also available. Please contact us at
21 // www.sensegraphics.com for more information.
22 //
23 //
27 //
29 #ifndef __THREAD_SAFE_FIELDS_H__
30 #define __THREAD_SAFE_FIELDS_H__
31 
32 #include <assert.h>
33 #include <H3D/PeriodicUpdate.h>
34 #include <H3DUtil/Threads.h>
35 
36 namespace H3D {
37 
53  template< class BaseField >
54  class ThreadSafeSField: public PeriodicUpdate< BaseField > {
55  public:
57  ThreadSafeSField(): rt_value_changed( false ) {}
58 
60  inline virtual void setValue( const typename BaseField::value_type &v,
61  int id = 0 ) {
62  if( H3DUtil::HapticThread::inHapticThread() ) {
63  rt_value = v;
64  rt_value_changed = true;
65  } else {
66  assert( H3DUtil::ThreadBase::inMainThread() );
67  PeriodicUpdate< BaseField >::setValue( v, id );
68  void * param[] = { &this->value, &rt_value };
69  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
70  }
71  }
72 
74  inline virtual const typename BaseField::value_type &getValue( int id = 0 ) {
75  if( H3DUtil::HapticThread::inHapticThread() ) {
76  return rt_value;
77  } else {
78  assert( H3DUtil::ThreadBase::inMainThread() );
79  return PeriodicUpdate< BaseField >::getValue( id );
80  }
81  }
82 
85  virtual void upToDate() {
86  assert( H3DUtil::ThreadBase::inMainThread() );
87 
88  if( rt_value_changed ) {
89  void * param[] = { &rt_value, &this->value };
90  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
91  this->startEvent();
92  } else {
93  PeriodicUpdate< BaseField >::upToDate();
94  }
95  }
96 
97  protected:
100  static H3DUtil::PeriodicThread::CallbackCode transferValue( void * _data ) {
101  void * * data = static_cast< void * * >( _data );
102  typename BaseField::value_type *new_value =
103  static_cast< typename BaseField::value_type * >( data[0] );
104  typename BaseField::value_type *rt_value =
105  static_cast< typename BaseField::value_type * >( data[1] );
106  *rt_value = *new_value;
107  return H3DUtil::PeriodicThread::CALLBACK_DONE;
108  }
109 
113  inline virtual void update() {
114  assert( H3DUtil::ThreadBase::inMainThread() );
115  PeriodicUpdate< BaseField >::update();
116  void * param[] = { &this->value, &rt_value };
117  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
118  }
119 
121  typename BaseField::value_type rt_value;
122 
125  bool rt_value_changed;
126  };
127 
144  template< class BaseField >
145  class ThreadSafeRefSField: public PeriodicUpdate< BaseField > {
146  public:
148  ThreadSafeRefSField(): rt_value_changed( false ) {}
149 
151  inline virtual void setValue( typename BaseField::value_type v,
152  int id = 0 ) {
153  if( H3DUtil::HapticThread::inHapticThread() ) {
154  rt_value.reset( v );
155  rt_value_changed = true;
156  } else {
157  assert( H3DUtil::ThreadBase::inMainThread() );
158  PeriodicUpdate< BaseField >::setValue( v, id );
159  void * param[] = { v, &rt_value };
160  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
161  }
162  }
163 
165  virtual typename BaseField::typed_value_type getValue( int id = 0 ) {
166  if( H3DUtil::HapticThread::inHapticThread() ) {
167  return static_cast< typename BaseField::typed_value_type >( rt_value.get() );
168  } else {
169  assert( H3DUtil::ThreadBase::inMainThread() );
170  return PeriodicUpdate< BaseField >::getValue( id );
171  }
172  }
173 
176  virtual void upToDate() {
177  assert( H3DUtil::ThreadBase::inMainThread() );
178 
179  if( rt_value_changed ) {
180  void * param[] = { rt_value.get(), &this->value };
181  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
182  this->startEvent();
183  } else {
184  PeriodicUpdate< BaseField >::upToDate();
185  }
186  }
187 
188  protected:
189  static H3DUtil::PeriodicThread::CallbackCode transferValue( void * _data ) {
190  void * * data = static_cast< void * * >( _data );
191  typename BaseField::value_type new_value =
192  static_cast< typename BaseField::value_type >( data[0] );
193  AutoRef< typename BaseField::class_type > *rt_value =
194  static_cast< AutoRef< typename BaseField::class_type> * >( data[1] );
195  rt_value->reset( new_value );
196  return H3DUtil::PeriodicThread::CALLBACK_DONE;
197  }
198 
200  virtual void onAdd( typename BaseField::value_type i ) {
201  assert( H3DUtil::ThreadBase::inMainThread() );
202  PeriodicUpdate< BaseField >::onAdd( i );
203  void * param[] = { i, &rt_value };
204  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
205  }
206 
208  AutoRef< typename BaseField::class_type > rt_value;
209 
212  bool rt_value_changed;
213  };
214 
230  template< class BaseField >
231  class ThreadSafeMField: public PeriodicUpdate< BaseField > {
232  public:
234  ThreadSafeMField(): rt_value_changed( false ) {}
235 
240  inline virtual void setValue(
241  const vector< typename BaseField::value_type > &v,
242  int id = 0 ) {
243  if( H3DUtil::HapticThread::inHapticThread() ) {
244  rt_value = v;
245  rt_value_changed = true;
246  } else {
247  assert( H3DUtil::ThreadBase::inMainThread() );
248  PeriodicUpdate< BaseField >::setValue( v, id );
249  void * param[] = { &this->value, &rt_value };
250  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
251  }
252  }
253 
259  inline virtual void setValue( typename BaseField::size_type i,
260  const typename BaseField::value_type &t,
261  int id = 0 ) {
262  if( H3DUtil::HapticThread::inHapticThread() ) {
263  rt_value[i] = t;
264  rt_value_changed = true;
265  } else {
266  assert( H3DUtil::ThreadBase::inMainThread() );
267  PeriodicUpdate< BaseField >::setValue( i, t, id );
268  void * param[] = { &this->value, &rt_value };
269  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
270  }
271  }
272 
274  inline virtual void swap( typename BaseField::vector_type &x, int id = 0 ) {
275  if( H3DUtil::HapticThread::inHapticThread() ) {
276  rt_value.swap( x );
277  rt_value_changed = true;
278  } else {
279  assert( H3DUtil::ThreadBase::inMainThread() );
280  PeriodicUpdate< BaseField >::swap( x, id );
281  void * param[] = { &this->value, &rt_value };
282  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
283  }
284  }
285 
287  inline virtual void push_back( const typename BaseField::value_type &x,
288  int id = 0 ) {
289  if( H3DUtil::HapticThread::inHapticThread() ) {
290  rt_value.push_back( x );
291  rt_value_changed = true;
292  } else {
293  assert( H3DUtil::ThreadBase::inMainThread() );
294  PeriodicUpdate< BaseField >::push_back( x, id );
295  void * param[] = { &this->value, &rt_value };
296  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
297  }
298  }
299 
301  void pop_back( int id = 0 ) {
302  if( H3DUtil::HapticThread::inHapticThread() ) {
303  rt_value.pop_back();
304  rt_value_changed = true;
305  } else {
306  assert( H3DUtil::ThreadBase::inMainThread() );
307  PeriodicUpdate< BaseField >::pop_back( id );
308  void * param[] = { &this->value, &rt_value };
309  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
310  }
311  }
312 
314  inline virtual void clear( int id = 0 ) {
315  if( H3DUtil::HapticThread::inHapticThread() ) {
316  rt_value.clear();
317  rt_value_changed = true;
318  } else {
319  assert( H3DUtil::ThreadBase::inMainThread() );
320  PeriodicUpdate< BaseField >::clear( id );
321  void * param[] = { &this->value, &rt_value };
322  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
323  }
324  }
325 
327  inline virtual typename BaseField::const_iterator begin( int id = 0 ) {
328  if( H3DUtil::HapticThread::inHapticThread() ) {
329  return rt_value.begin();
330  } else {
331  assert( H3DUtil::ThreadBase::inMainThread() );
332  return PeriodicUpdate< BaseField >::begin( id );
333  }
334  }
335 
337  inline virtual typename BaseField::const_iterator end( int id = 0 ) {
338  if( H3DUtil::HapticThread::inHapticThread() ) {
339  return rt_value.end();
340  } else {
341  assert( H3DUtil::ThreadBase::inMainThread() );
342  return PeriodicUpdate< BaseField >::end( id );
343  }
344  }
345 
350  inline virtual typename BaseField::const_reverse_iterator rbegin( int id = 0 ) {
351  if( H3DUtil::HapticThread::inHapticThread() ) {
352  return rt_value.rbegin();
353  } else {
354  assert( H3DUtil::ThreadBase::inMainThread() );
355  return PeriodicUpdate< BaseField >::rbegin( id );
356  }
357  }
362  inline virtual typename BaseField::const_reverse_iterator rend( int id = 0 ) {
363  if( H3DUtil::HapticThread::inHapticThread() ) {
364  return rt_value.rend();
365  } else {
366  assert( H3DUtil::ThreadBase::inMainThread() );
367  return PeriodicUpdate< BaseField >::rend( id );
368  }
369  }
370 
372  inline virtual unsigned int size() {
373  if( H3DUtil::HapticThread::inHapticThread() ) {
374  return rt_value.size();
375  } else {
376  assert( H3DUtil::ThreadBase::inMainThread() );
377  return PeriodicUpdate< BaseField >::size();
378  }
379  }
380 
382  inline virtual typename BaseField::size_type max_size() {
383  if( H3DUtil::HapticThread::inHapticThread() ) {
384  return rt_value.max_size();
385  } else {
386  assert( H3DUtil::ThreadBase::inMainThread() );
387  return PeriodicUpdate< BaseField >::max_size();
388  }
389  }
390 
393  inline virtual typename BaseField::size_type capacity() {
394  if( H3DUtil::HapticThread::inHapticThread() ) {
395  return rt_value.capacity();
396  } else {
397  assert( H3DUtil::ThreadBase::inMainThread() );
398  return PeriodicUpdate< BaseField >::capacity();
399  }
400  }
401 
403  inline virtual bool empty() {
404  if( H3DUtil::HapticThread::inHapticThread() ) {
405  return rt_value.empty();
406  } else {
407  assert( H3DUtil::ThreadBase::inMainThread() );
408  return PeriodicUpdate< BaseField >::empty();
409  }
410  }
412  inline virtual typename BaseField::const_reference operator[]( typename BaseField::size_type n ) {
413  if( H3DUtil::HapticThread::inHapticThread() ) {
414  return rt_value[n];
415  } else {
416  assert( H3DUtil::ThreadBase::inMainThread() );
417  return PeriodicUpdate< BaseField >::operator[]( n );
418  }
419  }
420 
422  inline virtual typename BaseField::const_reference front( int id = 0 ) {
423  if( H3DUtil::HapticThread::inHapticThread() ) {
424  return rt_value.front();
425  } else {
426  assert( H3DUtil::ThreadBase::inMainThread() );
427  return PeriodicUpdate< BaseField >::front( id );
428  }
429  }
430 
432  inline virtual typename BaseField::const_reference back( int id = 0 ) {
433  if( H3DUtil::HapticThread::inHapticThread() ) {
434  return rt_value.back();
435  } else {
436  assert( H3DUtil::ThreadBase::inMainThread() );
437  return PeriodicUpdate< BaseField >::back( id );
438  }
439  }
440 
442  inline virtual const typename BaseField::vector_type &getValue( int id = 0 ) {
443  if( H3DUtil::HapticThread::inHapticThread() ) {
444  return rt_value;
445  } else {
446  assert( H3DUtil::ThreadBase::inMainThread() );
447  return PeriodicUpdate< BaseField >::getValue( id );
448  }
449  }
450 
453  virtual void upToDate() {
454  assert( H3DUtil::ThreadBase::inMainThread() );
455 
456  if( rt_value_changed ) {
457  void * param[] = { &rt_value, &this->value };
458  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
459  this->startEvent();
460  } else {
461  PeriodicUpdate< BaseField >::upToDate();
462  }
463  }
464 
465  protected:
468  static H3DUtil::PeriodicThread::CallbackCode transferValue( void * _data ) {
469  void * * data = static_cast< void * * >( _data );
470  typename BaseField::vector_type *new_value =
471  static_cast< typename BaseField::vector_type * >( data[0] );
472  typename BaseField::vector_type *rt_value =
473  static_cast< typename BaseField::vector_type * >( data[1] );
474  *rt_value = *new_value;
475  return H3DUtil::PeriodicThread::CALLBACK_DONE;
476  }
477 
481  inline virtual void update() {
482  assert( H3DUtil::ThreadBase::inMainThread() );
483  PeriodicUpdate< BaseField >::update();
484  void * param[] = { &this->value, &rt_value };
485  H3DUtil::HapticThread::synchronousHapticCB( transferValue, param );
486  }
487 
489  typename BaseField::vector_type rt_value;
490 
493  bool rt_value_changed;
494  };
495 
496 }
497 
498 #endif
499 
500 
501 
502 
503 
504 
505 
PeriodicUpdate.h
Header file for PeriodicUpdate, template field modifier.
H3DUtil::AutoRef::get
RefCountedClassType * get() const
H3DUtil::AutoRef::reset
void reset(RefCountedClassType *p=0)
H3DUtil::HapticThreadBase::inHapticThread
static bool inHapticThread()
H3DUtil::HapticThreadBase::synchronousHapticCB
static void synchronousHapticCB(PeriodicThreadBase::CallbackFunc func, void *data)
H3DUtil::ThreadBase::inMainThread
static bool inMainThread()
H3D::PeriodicUpdate
The PeriodicUpdate is a template modifier that changes the way the field is updated.
Definition: PeriodicUpdate.h:74
H3D::PeriodicUpdate::upToDate
virtual void upToDate()
upToDate is specialized to record the time of the call to the function in the last_up_to_date member.
Definition: PeriodicUpdate.h:125
H3D::ThreadSafeMField
<>
Definition: ThreadSafeFields.h:231
H3D::ThreadSafeMField::size
virtual unsigned int size()
Returns the size of the vector.
Definition: ThreadSafeFields.h:372
H3D::ThreadSafeMField::empty
virtual bool empty()
true if the vector's size is 0.
Definition: ThreadSafeFields.h:403
H3D::ThreadSafeMField::setValue
virtual void setValue(const vector< typename BaseField::value_type > &v, int id=0)
Set the value of the field.
Definition: ThreadSafeFields.h:240
H3D::ThreadSafeMField::rbegin
virtual BaseField::const_reverse_iterator rbegin(int id=0)
Returns a const_reverse_iterator pointing to the beginning of the reversed vector.
Definition: ThreadSafeFields.h:350
H3D::ThreadSafeMField::ThreadSafeMField
ThreadSafeMField()
Constructor.
Definition: ThreadSafeFields.h:234
H3D::ThreadSafeMField::rt_value
BaseField::vector_type rt_value
The copy of the field value to be used in the haptics threads.
Definition: ThreadSafeFields.h:489
H3D::ThreadSafeMField::upToDate
virtual void upToDate()
Make sure that the field is up-to-date.
Definition: ThreadSafeFields.h:453
H3D::ThreadSafeMField::clear
virtual void clear(int id=0)
Erases all of the elements.
Definition: ThreadSafeFields.h:314
H3D::ThreadSafeMField::rt_value_changed
bool rt_value_changed
Flag indicating if the rt_value has been changed by a haptics thread.
Definition: ThreadSafeFields.h:493
H3D::ThreadSafeMField::transferValue
static H3DUtil::PeriodicThread::CallbackCode transferValue(void *_data)
Callback function to transfer copy a value between two pointers of the same type.
Definition: ThreadSafeFields.h:468
H3D::ThreadSafeMField::push_back
virtual void push_back(const typename BaseField::value_type &x, int id=0)
Inserts a new element at the end.
Definition: ThreadSafeFields.h:287
H3D::ThreadSafeMField::setValue
virtual void setValue(typename BaseField::size_type i, const typename BaseField::value_type &t, int id=0)
Change the value of one element in the MField.
Definition: ThreadSafeFields.h:259
H3D::ThreadSafeMField::update
virtual void update()
The update function is specialized to synchronize with the haptics threads and copy the new value of ...
Definition: ThreadSafeFields.h:481
H3D::ThreadSafeMField::swap
virtual void swap(typename BaseField::vector_type &x, int id=0)
Swaps the contents of two vectors.
Definition: ThreadSafeFields.h:274
H3D::ThreadSafeMField::operator[]
virtual BaseField::const_reference operator[](typename BaseField::size_type n)
Returns the n'th element.
Definition: ThreadSafeFields.h:412
H3D::ThreadSafeMField::back
virtual BaseField::const_reference back(int id=0)
Returns the last element.
Definition: ThreadSafeFields.h:432
H3D::ThreadSafeMField::front
virtual BaseField::const_reference front(int id=0)
Returns the first element.
Definition: ThreadSafeFields.h:422
H3D::ThreadSafeMField::getValue
virtual const BaseField::vector_type & getValue(int id=0)
Gets the value of the field.
Definition: ThreadSafeFields.h:442
H3D::ThreadSafeMField::rend
virtual BaseField::const_reverse_iterator rend(int id=0)
Returns a const_reverse_iterator pointing to the end of the reversed vector.
Definition: ThreadSafeFields.h:362
H3D::ThreadSafeMField::max_size
virtual BaseField::size_type max_size()
Returns the largest possible size of the vector.
Definition: ThreadSafeFields.h:382
H3D::ThreadSafeMField::end
virtual BaseField::const_iterator end(int id=0)
Returns a const_iterator pointing to the end of the vector.
Definition: ThreadSafeFields.h:337
H3D::ThreadSafeMField::pop_back
void pop_back(int id=0)
Removed the last element.
Definition: ThreadSafeFields.h:301
H3D::ThreadSafeMField::capacity
virtual BaseField::size_type capacity()
Number of elements for which memory has been allocated.
Definition: ThreadSafeFields.h:393
H3D::ThreadSafeMField::begin
virtual BaseField::const_iterator begin(int id=0)
Returns a const_iterator pointing to the beginning of the vector.
Definition: ThreadSafeFields.h:327
H3D::ThreadSafeRefSField
<>
Definition: ThreadSafeFields.h:145
H3D::ThreadSafeRefSField::onAdd
virtual void onAdd(typename BaseField::value_type i)
onAdd is extended to change the rt_image value in a thread safe way.
Definition: ThreadSafeFields.h:200
H3D::ThreadSafeRefSField::ThreadSafeRefSField
ThreadSafeRefSField()
Constructor.
Definition: ThreadSafeFields.h:148
H3D::ThreadSafeRefSField::getValue
virtual BaseField::typed_value_type getValue(int id=0)
Get the value of the field.
Definition: ThreadSafeFields.h:165
H3D::ThreadSafeRefSField::rt_value
AutoRef< typename BaseField::class_type > rt_value
The reference for the haptics loop.
Definition: ThreadSafeFields.h:208
H3D::ThreadSafeRefSField::rt_value_changed
bool rt_value_changed
Flag indicating if the rt_value has been changed by a haptics thread.
Definition: ThreadSafeFields.h:212
H3D::ThreadSafeRefSField::setValue
virtual void setValue(typename BaseField::value_type v, int id=0)
Set the value of the field.
Definition: ThreadSafeFields.h:151
H3D::ThreadSafeRefSField::upToDate
virtual void upToDate()
Make sure that the field is up-to-date.
Definition: ThreadSafeFields.h:176
H3D::ThreadSafeSField
<>
Definition: ThreadSafeFields.h:54
H3D::ThreadSafeSField::update
virtual void update()
The update function is specialized to synchronize with the haptics threads and copy the new value of ...
Definition: ThreadSafeFields.h:113
H3D::ThreadSafeSField::rt_value_changed
bool rt_value_changed
Flag indicating if the rt_value has been changed by a haptics thread.
Definition: ThreadSafeFields.h:125
H3D::ThreadSafeSField::getValue
virtual const BaseField::value_type & getValue(int id=0)
Get the value of the field.
Definition: ThreadSafeFields.h:74
H3D::ThreadSafeSField::ThreadSafeSField
ThreadSafeSField()
Constructor.
Definition: ThreadSafeFields.h:57
H3D::ThreadSafeSField::transferValue
static H3DUtil::PeriodicThread::CallbackCode transferValue(void *_data)
Callback function to transfer copy a value between two pointers of the same type.
Definition: ThreadSafeFields.h:100
H3D::ThreadSafeSField::setValue
virtual void setValue(const typename BaseField::value_type &v, int id=0)
Set the value of the field.
Definition: ThreadSafeFields.h:60
H3D::ThreadSafeSField::rt_value
BaseField::value_type rt_value
The copy of the field value to be used in the haptics threads.
Definition: ThreadSafeFields.h:121
H3D::ThreadSafeSField::upToDate
virtual void upToDate()
Make sure that the field is up-to-date.
Definition: ThreadSafeFields.h:85
operator[]
H3DDouble & operator[](int i)
x
H3DDouble x
H3D::X3D::Convert::getValue
Type getValue(const char *s, const char *&rest)
Function that reads characters from a char * and converts them to a given type.
Definition: X3DFieldConversion.h:134
H3D
H3D API namespace.
Definition: Anchor.h:38
Generated on Wed Sep 6 2023 10:29:39 for H3D API by doxygen 1.9.1