SField.h

Go to the documentation of this file.

//    Copyright 2004-2019, 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 __SFIELD_H__
#define __SFIELD_H__
 
#include <H3D/X3DFieldConversion.h>
#include <H3D/TypedField.h>
#include <H3D/Node.h>
 
namespace H3D {
 
 
  class H3DAPI_API SFieldClass {
  public:
    virtual ~SFieldClass() {};
 
    DEPRECATED( "int setValueFromVoidPtr( const void *data, unsigned int size, int id = 0 )", )
    virtual int setValueFromVoidPtr( void *data, unsigned int size, 
                                     int id = 0 ) {
      return setValueFromVoidPtr( (const void*)data, size, id );
    }
 
    virtual int getValueAsVoidPtr( void *data, unsigned int size, 
                                   int id = 0 ) = 0;
 
    virtual unsigned int valueTypeSize() = 0;
 
    virtual int setValueFromVoidPtr( const void *data, unsigned int size, 
                                     int id = 0 ) = 0;
  };
 
 
  template< class Type > 
  class SField: public TypedField< ParsableField,
                                   void,
                                   AnyNumber< SField< Type> > >,
                public SFieldClass {
  public:   
    typedef Type value_type;
 
    SField() {}
        
    SField( const Type &_value ) {
      value = _value;
    }
 
    inline virtual int setValueFromVoidPtr( const void *data, unsigned int len, 
                                            int id = 0 ) {
      if( len != sizeof( value_type ) )
        return -1;
      setValue( *( static_cast< const Type * >( data ) ), id );
      return 0;
    }
 
    inline virtual int getValueAsVoidPtr( void *data, unsigned int len, 
                                          int id = 0 ) {
      unsigned int size = sizeof( value_type );
      if( len < size ) {
        return -1;
      }
      *static_cast< Type * >( data ) = getValue( id );
      return size;
    } 
 
    inline virtual unsigned int valueTypeSize() {
      return sizeof( value_type );
    }
 
    inline virtual void setValue( const Type &v, int id = 0 );
 
    inline void setValueIfChanged( const Type &v, int id = 0 );
    inline virtual const Type &getValue( int id = 0 );
        
    inline virtual void setValueFromString( const string &s ) {
      this->setValue( X3D::X3DStringToValue< Type >( s ) ); 
    }
 
    inline virtual string getValueAsString( const string& /*separator*/ = " " ) {
      stringstream s;
      s << getValue();
      return s.str();
    }
  
    virtual string getTypeName() {
      return classTypeName();
    }
 
  static string classTypeName() { return typeid( SField< Type > ).name(); }
 
  protected:
    inline virtual void update();
 
    Type value;
 
  };
 
  template< class Type  >
  void SField< Type >::update() {
#ifdef DEBUG
    Console(LogLevel::Debug) << "SField< " << typeid( Type ).name() 
               << " >(" << this->name << ")::update()" << endl;
#endif
    if( this->owner )
      this->value = 
        static_cast< SField<Type>* >
        (this->event.ptr)->getValue( this->owner->id );
    else 
      this->value = 
        static_cast< SField<Type>* >(this->event.ptr)->getValue();
  }
 
  template< class Type >
  void SField<Type>::setValueIfChanged( const Type &v, int id ) {
#ifdef DEBUG
    Console(1) << "SField< " << typeid( Type ).name() 
               << " >(" << this->name << ")::setValue()" << endl;
#endif
    // check that we have the correct access type
    this->checkAccessTypeSet( id );
    
    // reset the event pointer since we want to ignore any pending
    // events when the field is set to a new value.
    this->event.ptr = NULL;
    if( value != v ) {
      value = v; 
     // generate an event.
      this->startEvent();
    }
  }
 
  template< class Type >
  void SField<Type>::setValue( const Type &v, int id ) {
#ifdef DEBUG
    Console(LogLevel::Debug) << "SField< " << typeid( Type ).name() 
               << " >(" << this->name << ")::setValue()" << endl;
#endif
    // check that we have the correct access type
    this->checkAccessTypeSet( id );
    
    value = v;
 
 
    // reset the event pointer since we want to ignore any pending
    // events when the field is set to a new value.
    this->event.ptr = NULL;
 
    // generate an event.
    this->startEvent();
 }
 
  template< class Type >
  const Type &SField<Type>::getValue( int id ) {
#ifdef DEBUG
    Console(LogLevel::Debug) << "SField< " << typeid( Type ).name() 
               << " >(" <<  this->name << ")::getValue()" << endl;
#endif
    // check that we have the correct access type
    this->checkAccessTypeGet( id );
 
    // check that the field is up-to-date first
    this->upToDate();
    return value;
  }
}
#endif