H3DNodeDatabase.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 __H3DNODEDATABSE_H__
#define __H3DNODEDATABSE_H__
 
#include <H3D/H3DApi.h>
#include <H3D/Field.h>
#include <iostream>
#include <string>
#include <map>
#include <list>
#include <typeinfo>
 
#define FIELDDB_ELEMENT( base, field, access ) \
FieldDBInsert field( access( &base::database, #field, &base::field ) );
 
#define FIELDDB_ELEMENT_EX( base, field, access, fieldst )           \
FieldDBInsert fieldst( access( &base::database, #fieldst, &base::field ) );
 
namespace H3D {
    
  class Node;
  typedef Node*( *H3DCreateNodeFunc)(); 
  
  struct H3DNodeDatabase;
  
  struct H3DAPI_API FieldDBElement {
    FieldDBElement( H3DNodeDatabase *_container,
                    const string & _name, 
                    const Field::AccessType _access );
    
    virtual ~FieldDBElement() {};
    
    H3DNodeDatabase* getContainer() {
      return container;
    }
 
    const string& getName() {
      return name;
    }
 
    Field::AccessType getAccessType() {
      return access;
    }
 
    virtual Field *getField( const Node * ) const { return NULL; };
    
  protected:
    H3DNodeDatabase *container;
    string name;   
    const Field::AccessType access;
  };
  
  struct H3DAPI_API DynamicFieldDBElement : FieldDBElement {
    DynamicFieldDBElement( H3DNodeDatabase *_container,
                           const string&_name, 
                           const Field::AccessType _access,
                           Field *_ptr ) :
      FieldDBElement( _container, _name, _access ), ptr( _ptr ) {}      
    
    virtual Field *getField( const Node *n ) const {
      if( ptr && n == ptr->getOwner() )
        return ptr;
      else
        return NULL;
    }
  protected:
    Field *ptr;
  };
 
 
  template< class N, class F >
  struct FieldDBTemplate : FieldDBElement {
    FieldDBTemplate( H3DNodeDatabase *_container,
                     const string& _name, 
                     const Field::AccessType _access,
                     H3DUniquePtr<F> N:: *_ptr ) :
      FieldDBElement( _container, _name, _access ), ptr( _ptr ) {}      
    
    virtual Field *getField( const Node *n ) const {
      const N *node = dynamic_cast<const N*>(n);
      if ( node ) 
        return (node->*ptr).get();
      else
        return NULL;
    }
  protected:
    const H3DUniquePtr<F> N:: *ptr;
  };
  
  template< class N, class F >
  inline FieldDBTemplate< N, F >* INITIALIZE_ONLY( H3DNodeDatabase *_container,
                                                   const std::string& _name, 
                                                   H3DUniquePtr<F> N:: *_ptr ) {
    return new FieldDBTemplate< N, F >( _container, 
                                        _name, 
                                        Field::INITIALIZE_ONLY, 
                                        _ptr );
  }  
 
  template< class N, class F >
  inline FieldDBTemplate< N, F >* OUTPUT_ONLY( H3DNodeDatabase *_container,
                                               const std::string &_name, 
                                               H3DUniquePtr<F> N:: *_ptr ) {
    return new FieldDBTemplate< N, F >( _container, 
                                        _name, 
                                        Field::OUTPUT_ONLY, _ptr );
  }  
 
  template< class N, class F >
  inline FieldDBTemplate< N, F >* INPUT_ONLY( H3DNodeDatabase *_container,
                                              const std::string &_name, 
                                              H3DUniquePtr<F> N:: *_ptr ) {
    return new FieldDBTemplate< N, F >( _container, 
                                        _name, 
                                        Field::INPUT_ONLY, 
                                        _ptr );
  }  
 
  template< class N, class F >
  inline FieldDBTemplate< N, F >* INPUT_OUTPUT( H3DNodeDatabase *_container,
                                                const std::string &_name, 
                                                H3DUniquePtr<F> N:: *_ptr ) {
    return new FieldDBTemplate< N, F >( _container, 
                                        _name, 
                                        Field::INPUT_OUTPUT, 
                                        _ptr );
  }  
  
  
  struct H3DAPI_API H3DNodeDatabase {
 
    struct TypeInfoWrapper {
      const std::type_info& t; 
 
      TypeInfoWrapper (const std::type_info& t_) 
        : t (t_) {} 
 
      bool operator< (const TypeInfoWrapper & o) const { 
        return t.before (o.t) != 0; 
      } 
    };
 
    typedef map< string, FieldDBElement* > FieldDBType;
    typedef map< TypeInfoWrapper, H3DNodeDatabase* > H3DNodeDatabaseType;
    typedef H3DNodeDatabaseType::const_iterator NodeDatabaseConstIterator;
 
    class H3DAPI_API FieldDBConstIterator {
    public:
      FieldDBConstIterator( H3DNodeDatabase * _ndb , bool is_end );
 
      FieldDBConstIterator( const FieldDBConstIterator &f );
 
      FieldDBConstIterator & operator=(const FieldDBConstIterator &rhs);
 
      inline FieldDBConstIterator &operator++(int) {
        return operator++();
      } 
      
      FieldDBConstIterator &operator++();
 
      bool operator==( FieldDBConstIterator iter );
 
      inline bool operator!=( FieldDBConstIterator iter ) {
        return !operator==( iter );
      }
      
      inline string operator*() { 
        if( status == INHERITED )
          return *(*inherited_iterator);
        else 
          return (*local_iterator).first;
      }
 
      inline FieldDBElement *getFieldDBElement() {
        if( status == INHERITED )
          return (*inherited_iterator).getFieldDBElement();
        else 
          return (*local_iterator).second;
      }
 
      inline Field * getField( Node *n ) {
        if( status == INHERITED )
          return (*inherited_iterator).getField( n );
        else 
          return (*local_iterator).second->getField( n ) ;
      }
      
    protected:
      FieldDBConstIterator():
        status( END ),
        ndb( NULL ) {}
 
      typedef enum {
        LOCAL,
        INHERITED,
        END
      } Status;
      
      Status status;
      FieldDBType::const_iterator local_iterator;
      H3DUniquePtr< FieldDBConstIterator > inherited_iterator;
      H3DNodeDatabase * ndb;
    };
#ifdef __BORLANDC__
    friend class FieldDBConstIterator;
#endif
 
 
    H3DNodeDatabase( const string&_name, 
                     H3DCreateNodeFunc _createf,
                     const type_info &_ti,
                     H3DNodeDatabase *_parent = 0 );
 
    H3DNodeDatabase( const string&_name, 
                     const string &_alias,
                     H3DCreateNodeFunc _createf,
                     const type_info &_ti,
                     H3DNodeDatabase *_parent = 0 );
 
    H3DNodeDatabase( const type_info &_ti,
                     H3DNodeDatabase *_parent = 0 );
    ~H3DNodeDatabase(void);
    
    static H3DNodeDatabase *lookupTypeId( const type_info &t );
 
    static H3DNodeDatabase *lookupName( const string &name );
    
    inline void addAlias( const string &alias ) {
      aliases.push_back( alias );
    }
 
    static Node *createNode( const string &name );
 
    inline const string &getName() {
      return name;
    }
 
    inline const type_info &getTypeInfo() {
      return ti;
    }
 
    inline Node * createNode() {
      if( createf ) return createf();
      else return NULL;
    }
 
    void addField( FieldDBElement *f );
    
    bool removeField ( const string& _name, Node* _node= NULL );
 
    Field *getField( const Node * n, const string& f ) const;
    
    void initFields( Node* ) const;
 
    void clearDynamicFields();
 
    void clearDynamicFields( Node *n );
    
  private:
    Field *getFieldHelp( const Node * n, const string& f ) const;
 
    string name;
 
    const H3DCreateNodeFunc createf;
    
    const type_info &ti;
    
    H3DNodeDatabase *parent;
    
    FieldDBType fields;
    
    static bool initialized;
 
    list< string > aliases;
    
  public:
    static H3DNodeDatabaseType *database;
 
    static NodeDatabaseConstIterator begin() {
      return database->begin();
    }
    
    static NodeDatabaseConstIterator end() {
      return database->end();
    }
 
    FieldDBConstIterator fieldDBBegin() {
      return FieldDBConstIterator( this, 0 );
    }
    
    FieldDBConstIterator fieldDBEnd()  {
      return FieldDBConstIterator( this,1 );
    }
    
    inline size_t fieldDBSize() {
      if( !parent ) {
        return fields.size();
      } else {
        return fields.size() + parent->fieldDBSize();
      }
    }
 
    H3DNodeDatabase( const Node * n,
                     H3DNodeDatabase *_parent );
 
    typedef map< const Node *, H3DNodeDatabase* > H3DNodeInstanceDatabase;
    static H3DNodeDatabase *lookupNodeInstance( const Node * n );
  protected:
    H3DNodeInstanceDatabase node_instance_database;
    bool database_allocated_dynamic;
    
  };
    
  struct FieldDBInsert {
    FieldDBInsert( FieldDBElement *f ) {
      f->getContainer()->addField( f );
    }
  };
  
 
}
 
#endif