Field.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 __FIELD_H__
#define __FIELD_H__
 
#include <iostream>
#include <string>
#include <set>
#include <vector>
#include <H3D/H3DApi.h>
#include <H3D/H3DTypes.h>
#include <H3DUtil/TimeStamp.h>
#include <H3D/X3DTypes.h>
#include <memory>
 
namespace H3D {
  // forward declaration
  class Node;
 
  class H3DAPI_API Field {
  public:
    H3D_API_EXCEPTION( FieldAccessError );
 
    typedef enum {
      INITIALIZE_ONLY,
      OUTPUT_ONLY,
      INPUT_ONLY,
      INPUT_OUTPUT 
    } AccessType;
 
    struct H3DAPI_API Event {
 
      Event( Field *_ptr, const TimeStamp &_time_stamp ):
        ptr( _ptr ),
        time_stamp( _time_stamp ) {
      }
 
      Field *ptr;
 
      TimeStamp time_stamp;
 
      static H3DTime generateEventTime() {
        H3DTime event_time = TimeStamp::now ();
        if( event_time <= last_event_time ) {
#ifdef DEBUG
          Console(LogLevel::Debug) << "Field: New event has same timestamp as last generated event, incrementing timestamp" << std::endl;
#endif          
          // Casting a pointer to last_event_time to a long long (which is at least 64bit) so we can increment it, thus incrementing the mantissa of last_event_time and getting us the smallest possible higher value
          unsigned long long* temp = reinterpret_cast<unsigned long long*>(&last_event_time);
          ++(*temp);
          event_time = last_event_time;
        }
        last_event_time = event_time;
        return event_time;
      }
 
    protected:
 
      static H3DTime last_event_time;
    };    
 
    Field();
    
    virtual ~Field();
 
    virtual void checkFieldType( Field *f, int index );
 
    void setName( string _name ) { name = _name; }
 
    string getName();
 
    string getFullName();
 
    virtual string getTypeName() { return classTypeName(); }
 
    virtual X3DTypes::X3DType getX3DType() { return X3DTypes::UNKNOWN_X3D_TYPE; }
 
    static string classTypeName() { return "Field"; }
 
    virtual void route( Field*, int id = 0 );
 
    virtual void routeNoEvent( Field*, int id = 0 );
    
    virtual void unroute( Field* );
 
    virtual Field *replaceRoute( Field* f, unsigned int i, int id = 0 );
 
    virtual Field *replaceRouteNoEvent( Field* f, unsigned int i, int id = 0 );
 
    template< class F >
    inline void route( H3DUniquePtr< F > &f, int id = 0 ) { 
      route( f.get(), id ); }
 
    template< class F >
    inline void routeNoEvent( H3DUniquePtr< F > &f, int id = 0 ) { 
      routeNoEvent( f.get(), id ); 
    }
 
    template< class F >
    void unroute( H3DUniquePtr< F > &f ) { unroute( f.get() ); }
 
    inline void unrouteAll() {
      while( routes_out.begin() != routes_out.end() ) {
        unroute( *routes_out.begin() );
      }
    }
 
    virtual void upToDate();
    
    inline bool isUpToDate() {
      return event.ptr == NULL;
    }
 
    virtual void touch();
 
    inline Node *getOwner() {
      return owner;
    }
 
    void setOwner( Node *n );
 
    inline void setAccessType( AccessType _access_type ) {
      access_type = _access_type;
    }
 
    inline AccessType getAccessType() {
      return access_type;
    }
 
    typedef vector< Field * > FieldSet;
    typedef vector< Field * > FieldVector;
 
    inline bool routesTo( Field *f ) {
      for( FieldSet::const_iterator i = routes_out.begin();
           i != routes_out.end(); ++i ) {
        if( (*i) == f ) return true;
      }
      return false;
    }
 
    inline bool hasRouteFrom( Field *f ) {
      for( FieldVector::const_iterator i = routes_in.begin();
           i != routes_in.end(); ++i ) {
        if( (*i) == f ) return true;
      }
      return false;
    }
 
    inline const FieldVector &getRoutesIn() {
      return routes_in;
    }
    
    inline const FieldSet &getRoutesOut() {
      return routes_out;
    }
 
    inline const Event &getLatestEvent() {
      return event;
    }
 
    inline void setAccessCheck( bool on ) {
      access_check_on = on;
    }
 
    inline bool isAccessCheckOn() {
      return access_check_on;
    }
 
  protected:
    virtual void startEvent();
 
    virtual void propagateEvent( Event e );
    
    virtual void routeFrom( Field*, int id );
 
    virtual void unrouteFrom( Field* );
 
    virtual Field *replaceRouteFrom( Field* f, unsigned int i, int id );
 
    virtual void update() {}
 
    void checkAccessTypeRoute( Field *f, int id );
 
    void checkAccessTypeRouteFrom( Field *f, int id );
 
    void checkAccessTypeGet( int id );
 
    void checkAccessTypeSet( int id );
 
    int ownerId();
 
    string name;
 
    bool event_lock;
 
    bool update_lock;
 
    FieldSet routes_out;
    FieldVector routes_in;
    Event event;
    Node *owner;
    AccessType access_type;
    bool access_check_on;
 
    friend class Scene;
 
    bool isProgramSetting() {
      return is_program_setting;
    }
 
    void markProgramSetting( bool used_as_setting ) {
      is_program_setting = used_as_setting;
    }
 
    bool is_program_setting;
  };
 
  class H3DAPI_API ParsableField: public Field {
  public:
    virtual void setValueFromString( const string &s ) = 0;
    inline virtual string getValueAsString( const string& /*separator*/ = " " ) {
      return "";
    }
  };
 
  class H3DAPI_API ParsableMField: public ParsableField {
  public:
    virtual size_t getSize( ) = 0;
    inline virtual string getElementAsString( size_t /*element*/ ) {
      return "";
    }
    inline virtual void addElementFromString( const string &s ) = 0;
  };
 
 
}
 
#endif