Field.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 __FIELD_H__
#define __FIELD_H__

#include <iostream>
#include <string>
#include <set>
#include <vector>
#include "H3DApi.h"
#include "H3DTypes.h"
#include "TimeStamp.h"
#include "X3DTypes.h"

using namespace std;

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

    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( auto_ptr< F > &f, int id = 0 ) { 
      route( f.get(), id ); }

    template< class F >
    inline void routeNoEvent( auto_ptr< F > &f, int id = 0 ) { 
      routeNoEvent( f.get(), id ); 
    }

    template< class F >
    void unroute( auto_ptr< 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;
    }

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

  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

---