MField.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 __MFIELD_H__
#define __MFIELD_H__
 
#include <string>
#include <set>
#include <vector>
#include <algorithm>
 
#include <H3D/TypedField.h>
#include <H3D/Node.h>
#include <H3D/X3DFieldConversion.h>
 
namespace H3D {
 
  class H3DAPI_API MFieldClass {
  public:
    virtual ~MFieldClass() {};
 
    DEPRECATED( "int setValueFromVoidPtr( const void *data, unsigned int nr_elements, unsigned int size, int id = 0 )", )
 
    virtual int setValueFromVoidPtr( void *data, unsigned int nr_elements, 
                                     unsigned int size, int id = 0 ) {
      return setValueFromVoidPtr( (const void*)data, nr_elements, size, id );
    }
 
    virtual int getValueAsVoidPtr( void *data, unsigned int &nr_elements,
                                   unsigned int size, int id = 0 ) = 0;
 
    virtual unsigned int valueTypeSize() = 0;
 
    virtual unsigned int size() = 0; 
 
    virtual int setValueFromVoidPtr( const void *data, unsigned int nr_elements, 
                                     unsigned int size, int id = 0 ) = 0;
  };
 
 
  template< class Type, 
            class VectorClass = std::vector< Type >, 
            class BaseField  = ParsableMField > 
  class MFieldBase: public TypedField< BaseField,
                                       void,
                                       AnyNumber< MFieldBase< Type, 
                                                              VectorClass, 
                                                              BaseField > > >,
                    public MFieldClass {
  public:
    typedef VectorClass vector_type;
    typedef VectorClass vector_return_type;
    typedef typename VectorClass::value_type value_type;
    typedef typename VectorClass::pointer pointer;
    typedef typename VectorClass::const_reference const_reference;
    typedef typename VectorClass::size_type size_type;
    typedef typename VectorClass::difference_type difference_type;  
    typedef typename VectorClass::const_iterator const_iterator;
    typedef typename VectorClass::const_reverse_iterator 
    const_reverse_iterator;
 
    inline const_iterator begin( int id = 0 ) { 
      // check that we have the correct access type
      this->checkAccessTypeGet( id );
      this->upToDate();
      return value.begin();
    }
    
    inline const_iterator end( int id = 0 ) { 
      // check that we have the correct access type
      this->checkAccessTypeGet( id );
      this->upToDate();
      return value.end(); 
    }
    
    inline const_reverse_iterator rbegin( int id = 0 ) { 
      // check that we have the correct access type
      this->checkAccessTypeGet( id );
      this->upToDate();
      return value.rbegin();
    }
    
    inline const_reverse_iterator rend( int id = 0 ) { 
      // check that we have the correct access type
      this->checkAccessTypeGet( id );
      this->upToDate();
      return value.rend(); 
    }
 
    inline unsigned int size() { 
      this->upToDate();
      return (unsigned int)value.size(); 
    }
 
    inline size_type max_size() {
      this->upToDate();
      return value.max_size();
    }
        
    inline size_type capacity() { 
      this->upToDate();
      return value.capacity(); 
    }
        
    inline void reserve( size_type s ) { 
      this->upToDate();
      value.reserve( s ); 
    }
 
    inline void resize( size_type n, Type t = Type(), int id = 0 ) { 
      this->checkAccessTypeSet( id );
      this->upToDate();
      value.resize( n, t );
      this->startEvent();
    }
 
    inline bool empty() { 
      this->upToDate();
      return value.empty();
    }
 
    inline const_reference operator[](size_type n ) {
      // check that we have the correct access type
      this->checkAccessTypeGet( 0 );
      this->upToDate();
      return value[n];
    }
 
    inline const_reference front( int id = 0 ) { 
      // check that we have the correct access type
      this->checkAccessTypeGet( id );
      this->upToDate();
      return value.front(); 
    }
 
    inline const_reference back( int id = 0 ) {
      // check that we have the correct access type
      this->checkAccessTypeGet( id );
      this->upToDate();
      return value.back(); 
    }
 
    inline void swap( VectorClass &x, int id = 0 ) {
      // check that we have the correct access type
      this->checkAccessTypeSet( id );
      this->checkAccessTypeGet( id );
      this->upToDate();
      this->value.swap( x );
      this->startEvent();
    }
 
    inline void push_back( const Type &x, int id = 0 ) {
      // check that we have the correct access type
      this->checkAccessTypeSet( id );
      this->upToDate();    
      this->value.push_back( x );
      this->startEvent();
    }
 
    void pop_back( int id = 0 ) {
      // check that we have the correct access type
      this->checkAccessTypeSet( id );
      this->upToDate();
      value.pop_back();
      this->startEvent();
    }
 
    inline void clear( int id = 0 ) {
      // check that we have the correct access type
      this->checkAccessTypeSet( id );
      value.clear();
      this->startEvent();
    }
 
    inline virtual int setValueFromVoidPtr( const void *data, 
                                            unsigned int nr_elements, 
                                            unsigned int len, int id = 0 ) {
      this->checkAccessTypeSet( id );
          
      if( len != sizeof( value_type ) * nr_elements )
      return -1;
      
      std::vector< Type > new_data( nr_elements );
      for( unsigned int i = 0; i < nr_elements; ++i ) {
        new_data[i] = static_cast< const value_type * >( data )[i];
      }
      this->value.swap( new_data );
      this->startEvent();
      return 0;
    }
 
H3D_PUSH_WARNINGS()
H3D_DISABLE_UNUSED_PARAMETER_WARNING()
    inline virtual int getValueAsVoidPtr( void *data, 
                                          unsigned int &nr_elements,
                                          unsigned int len, 
                                          int id = 0 ) {
      unsigned int sz = sizeof( value_type );
      nr_elements = (unsigned int) this->value.size();
      if( len < sz * nr_elements ) {
        return -1;
      }
      
      value_type *data_ptr = 
        static_cast< value_type * >( data );
 
      this->upToDate();
 
      for( unsigned int i = 0; i < nr_elements; ++i ) {
        data_ptr[i] = value[i];
      }
      return sz * nr_elements;
    }
H3D_POP_WARNINGS()
 
    
    inline virtual unsigned int valueTypeSize() {
      return sizeof( value_type );
    }
 
    MFieldBase() {};
 
    MFieldBase( size_type sz ) : value( sz ) {};
 
    static string classTypeName() {
      return typeid( MFieldBase< Type, VectorClass, BaseField > ).name();
    }
 
  protected:
    VectorClass value;
  };
 
  template< class Type >
  class MField: public MFieldBase< Type, 
                                   std::vector< Type >, 
                                   ParsableMField > {
    typedef MFieldBase< Type, 
                        std::vector< Type >, 
                        ParsableMField > BaseMField;
     
  public:
    typedef typename std::vector< Type >::iterator iterator;
 
    H3D_VALUE_EXCEPTION( typename BaseMField::size_type, InvalidIndex );
 
    MField() {}
 
    MField( typename BaseMField::size_type sz ) : 
      BaseMField( sz ) {}
        
    inline virtual const std::vector< Type > &getValue( int id = 0 );
 
    inline virtual typename std::vector<Type>::const_reference
    getValueByIndex( typename BaseMField::size_type i, int id = 0 ) {
#ifdef DEBUG
      Console(LogLevel::Debug) << "MField(" << 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();
      // i < 0 is never true..
      if( /*i < 0 || */ i >= this->value.size() ) {
        stringstream s;
        s << "Trying to access value outside the bounds of field "
          << this->getFullName() << ". Field has size " << this->value.size()
          << ". ";
        throw InvalidIndex( i, s.str(), H3D_FULL_LOCATION );
      }
      return this->value[i];    
    }
 
    inline virtual void setValue( const std::vector< Type > &v, int id = 0  );
 
    inline virtual void setValue( typename BaseMField::size_type i,
                                  const Type &v, int id = 0  ) {
#ifdef DEBUG
      Console(LogLevel::Debug) << "MField< " << typeid( Type ).name() 
           << " >(" << this->name << ")::setValue()" << endl;
#endif
      // check that we have the correct access type
      this->checkAccessTypeSet( id );
      this->value[i] = v; //.set( i, 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();                                  
    }
 
    inline virtual void setValueFromString( const string &s ) {
      std::vector< Type > v;
      X3D::X3DStringToVector< std::vector< Type > >( s, v ); 
      setValue( v );
    }
 
    inline virtual void addElementFromString( const string &s ) {
      this->push_back(  X3D::X3DStringToValue< Type >( s )  );
    }
 
    inline virtual string getValueAsString( const string& separator = " " ) {
      stringstream s;
      const std::vector< Type > &v = getValue();
      
      if( v.size() == 0 )
        return "";
      unsigned int i;
      for( i = 0; i < v.size() - 1; ++i )
        s << v[i] << separator;
      s << v[i];
      return s.str();
    }
 
    inline typename MField<Type>::const_iterator insert( typename MField<Type>::const_iterator pos,
                     const Type &x, 
                     int id = 0 ) {
      this->checkAccessTypeSet( id );
      this->upToDate();
      iterator i = this->value.insert( this->iteratorFromConst ( pos ), x );
      this->startEvent();
      return i;
    }
        
   template <class InputIterator>
   void insert(typename MField<Type>::const_iterator pos,
               InputIterator first, 
               InputIterator last,
               int id = 0 ) {
     this->checkAccessTypeSet( id );
     this->upToDate();
     this->value.insert( this->iteratorFromConst ( pos ), first, last );
     this->startEvent();
   } 
            
    inline void insert(typename MField<Type>::const_iterator pos, 
                       typename BaseMField::size_type n, const Type &x, int id = 0 ) {
      this->checkAccessTypeSet( id );
      this->upToDate();
      this->value.insert( this->iteratorFromConst ( pos ), n, x );
      this->startEvent();
    }
    
    inline virtual void erase( typename MField<Type>::const_iterator pos, int id = 0 ) { 
      this->checkAccessTypeSet( id );
      this->upToDate();
      this->value.erase( this->iteratorFromConst ( pos ) );
      this->startEvent();
    }
        
    inline virtual void erase( typename MField<Type>::const_iterator first, 
                               typename MField<Type>::const_iterator last, int id = 0 ) {
      this->checkAccessTypeSet( id );
      this->upToDate();
      this->value.erase( 
        this->iteratorFromConst ( first ), 
        this->iteratorFromConst ( last ) );
      this->startEvent();
    }
    
    
    inline virtual void erase( const Type &a, int /*id*/ = 0 ) {
      iterator i = std::find( this->value.begin(), this->value.end(), a );
      if( i != this->value.end() ) {
        this->value.erase( i );
      }
    } 
 
    virtual string getTypeName() {
      return this->classTypeName();
    }
 
    virtual size_t getSize( ) {
      const std::vector< Type > &v = getValue();
      return v.size();
    }
 
    inline virtual string getElementAsString( size_t element ) {
      stringstream s;
      const std::vector< Type > &v = getValue();
      
      if( element >= v.size() )
        throw InvalidIndex( element, "getElementAsString", H3D_FULL_LOCATION );
      
      s << v[element];
      return s.str();
    }
 
 
  protected:
    inline virtual void update();
 
    inline iterator iteratorFromConst ( typename MField<Type>::const_iterator pos ) {
      return this->value.begin()+(pos-this->value.begin());
    }
  };
 
  template< class Type  >
  void MField< Type >::update() {
#ifdef DEBUG
    Console(LogLevel::Debug) << "MField< " << typeid( Type ).name() 
         << " >(" << this->name << ")::update()" << endl;
#endif
    if( this->owner )
      this->value = 
        static_cast< MField<Type>* >
        (this->event.ptr)->getValue( this->owner->id );
    else 
      this->value = 
        static_cast< MField<Type>* >(this->event.ptr)->getValue();
  }
 
  template< class Type  >
  void MField< Type >::setValue( const std::vector< Type > &v, int id ) {
#ifdef DEBUG
    Console(LogLevel::Debug) << "MField< " << typeid( Type ).name() 
         << " >(" << this->name << ")::setValue()" << endl;
#endif
    // check that we have the correct access type
    this->checkAccessTypeSet( id );
    this->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 std::vector< Type > &MField<Type >::getValue( int id ) {
#ifdef DEBUG
    Console(LogLevel::Debug) << "MField< " << 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 this->value;
  }
    
}
 
#endif