H3DNodeDatabase.h

Go to the documentation of this file.

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

#include "H3DApi.h"
#include "Field.h"
#include <iostream>
#include <string>
#include <map>

using namespace std;


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

    const Field::AccessType getAccessType() {
      return access;
    }

    virtual Field *getField( Node *n ) 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( 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,
                     auto_ptr<F> N:: *_ptr ) :
      FieldDBElement( _container, _name, _access ), ptr( _ptr ) {}      
    
    virtual Field *getField( Node *n ) const {
      N *node = dynamic_cast<N*>(n);
      if ( node ) 
        return (node->*ptr).get();
      else
        return NULL;
    }
  protected:
    const auto_ptr<F> N:: *ptr;
  };
  
  template< class N, class F >
  inline FieldDBTemplate< N, F >* INITIALIZE_ONLY( H3DNodeDatabase *_container,
                                                   const string& _name, 
                                                   auto_ptr<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 string &_name, 
                                               auto_ptr<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 string &_name, 
                                              auto_ptr<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 string &_name, 
                                                auto_ptr<F> N:: *_ptr ) {
    return new FieldDBTemplate< N, F >( _container, 
                                        _name, 
                                        Field::INPUT_OUTPUT, 
                                        _ptr );
  }  
  
  
        struct H3DAPI_API H3DNodeDatabase {
    typedef map< string, FieldDBElement* > FieldDBType;
    typedef map< string, H3DNodeDatabase*> H3DNodeDatabaseType;
    typedef H3DNodeDatabaseType::const_iterator NodeDatabaseConstIterator;

    class H3DAPI_API FieldDBConstIterator {
    public:
      FieldDBConstIterator( H3DNodeDatabase * _ndb , bool is_end );

      FieldDBConstIterator( const FieldDBConstIterator &f ):
        status( f.status ),
        local_iterator( f.local_iterator ),
        inherited_iterator( new FieldDBConstIterator ),
        ndb( f.ndb ) {
        *inherited_iterator = *f.inherited_iterator;
      }

      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;
      }
      
    protected:
      FieldDBConstIterator(){}

      typedef enum {
        LOCAL,
        INHERITED,
        END
      } Status;
      
      Status status;
      FieldDBType::const_iterator local_iterator;
      FieldDBConstIterator* inherited_iterator;
      H3DNodeDatabase * ndb;
    };


          H3DNodeDatabase( const string&_name, 
                     H3DCreateNodeFunc _createf,
                     const type_info &_ti,
                     H3DNodeDatabase *_parent = 0 );

          H3DNodeDatabase( const type_info &_ti,
                     H3DNodeDatabase *_parent = 0 );
    
    static H3DNodeDatabase *lookupTypeId( const type_info &t );

    static H3DNodeDatabase *lookupName( const string &name );
    
          static Node *createNode( const string &name );

    void addField( FieldDBElement *f );
    
    Field *getField( Node *n, const string& f ) const;
    
    void initFields( Node* ) const;
    
        private:
    Field *getFieldHelp( Node *n, const string& f ) const;

    string name;

    const H3DCreateNodeFunc createf;
    
    const type_info &ti;
    
    H3DNodeDatabase *parent;
    
    FieldDBType fields;
    
                static bool initialized;
    
  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();
      }
                }
    
        };
          
  struct FieldDBInsert {
    FieldDBInsert( FieldDBElement *f ) {
      f->getContainer()->addField( f );
    }
  };
  

}

#endif

---