MField.h

//    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 __MFIELD_H__
#define __MFIELD_H__

#include <string>
#include <set>
#include <vector>
#include <algorithm>

#include "TypedField.h"
#include "Node.h"
#include "X3DFieldConversion.h"

using namespace std;

namespace H3D {

  class H3DAPI_API MFieldClass {
  public:
    // Virtual destructor.
    virtual ~MFieldClass() {};

    virtual int setValueFromVoidPtr( void *data, unsigned int nr_elements, 
                                     unsigned int size, int id = 0 ) = 0;

    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; 
  };


  template< class Type, 
            class VectorClass = vector< Type >, 
            class BaseField  = ParsableMField > 
  class MFieldBase: public TypedField< BaseField,
                                       void,
                                       AnyNumber< MFieldBase< Type, 
                                                              VectorClass, 
                                                              BaseField > > >,
                    public MFieldClass {
  public:
    typedef VectorClass vector_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 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_t s ) { 
      this->upToDate();
      value.reserve( s ); 
    }

    inline  void resize( size_t n, Type t = Type(), int id = 0 ) { 
      this->checkAccessTypeSet( id );
      this->upToDate();
      value.resize( n ); 
      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 );
      this->upToDate();
      value.clear();
      this->startEvent();
    }

    inline virtual int setValueFromVoidPtr( void *data, 
                                            unsigned int nr_elements, 
                                            unsigned int len, int id = 0 ) {
      this->checkAccessTypeSet( id );
          
      if( len != sizeof( value_type ) * nr_elements )
      return -1;
      
      vector< Type > new_data( nr_elements );
      for( unsigned int i = 0; i < nr_elements; i++ ) {
        new_data[i] = static_cast< value_type * >( data )[i];
      }
      this->value.swap( new_data );
      this->startEvent();
      return 0;
    }

    inline virtual int getValueAsVoidPtr( void *data, 
                                          unsigned int &nr_elements,
                                          unsigned int len, 
                                          int id = 0 ) {
      unsigned int sz = sizeof( value_type );
      nr_elements = 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;
    } 

    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, 
                                   vector< Type >, 
                                   ParsableMField > {
    typedef MFieldBase< Type, 
                        vector< Type >, 
                        ParsableMField > BaseMField;
     
  public:
    typedef typename vector< Type >::iterator iterator;

    H3D_VALUE_EXCEPTION( typename BaseMField::size_type, InvalidIndex );

    MField() {}

    MField( typename BaseMField::size_type sz ) : 
      BaseMField( sz ) {}
        
    inline virtual const vector< Type > &getValue( int id = 0 );

    inline virtual typename MField<Type>::const_reference 
    getValueByIndex( typename BaseMField::size_type i, int id = 0 ) {
#ifdef DEBUG
      Console(1) << "MField(" << 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();
      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 vector< Type > &v, int id = 0  );

    inline virtual void setValue( typename BaseMField::size_type i,
                                  const Type &v, int id = 0  ) {
#ifdef DEBUG
      Console(1) << "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 ) {
      vector< Type > v;
      X3D::X3DStringToVector< vector< Type > >( s, v ); 
      setValue( v );
    }

    inline virtual void addElementFromString( const string &s ) {
      push_back(  X3D::X3DStringToValue< Type >( s )  );
    }

    inline virtual string getValueAsString( const string& separator = " " ) {
      stringstream s;
      const 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 iterator insert( iterator pos,
                     const Type &x, 
                     int id = 0 ) {
      this->checkAccessTypeSet( id );
      this->upToDate();
      iterator i = this->value.insert( pos, x );
      this->startEvent();
      return i;
    }
        
   template <class InputIterator>
   void insert(iterator pos,
               InputIterator first, 
               InputIterator last,
               int id = 0 ) {
     this->checkAccessTypeSet( id );
     this->upToDate();
     this->value.insert( pos, first, last );
     this->startEvent();
   } 
            
    inline void insert(iterator pos, 
                       typename BaseMField::size_type n, const Type &x, int id = 0 ) {
      this->checkAccessTypeSet( id );
      this->upToDate();
      this->value.insert( pos, n, x );
      this->startEvent();
    }
    
    inline virtual void erase( iterator pos, int id = 0 ) { 
      this->checkAccessTypeSet( id );
      this->upToDate();
      this->value.erase( pos );
      this->startEvent();
    }
        
    inline virtual void erase( iterator first, iterator last, int id = 0 ) {
      this->checkAccessTypeSet( id );
      this->upToDate();
      this->value.erase( first, 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 vector< Type > &v = getValue();
      return v.size();
    }

    inline virtual string getElementAsString( size_t element ) {
      stringstream s;
      const 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();
  };

  template< class Type  >
  void MField< Type >::update() {
#ifdef DEBUG
    Console(1) << "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 vector< Type > &v, int id ) {
#ifdef DEBUG
    Console(1) << "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 vector< Type > &MField<Type >::getValue( int id ) {
#ifdef DEBUG
    Console(1) << "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

---