DependentNodeFields.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 __DEPENDENTNODEFIELDS_H__
#define __DEPENDENTNODEFIELDS_H__
 
#include <H3D/SFNode.h>
#include <H3D/MFNode.h>
 
namespace H3D {
 
  template< class NodeType, 
            class FieldType, 
            H3DUniquePtr< FieldType > NodeType:: *member_ptr >
  class FieldRef {
  public:
    typedef NodeType node_type;
    typedef FieldType field_type;
    typedef H3DUniquePtr< FieldType > NodeType:: * member_ptr_type;
    static Field *getField( NodeType *n ) {
      return (n->*member_ptr).get();
    }
    static member_ptr_type getMemberPtr() {
      return member_ptr;
    }
  };
 
  namespace FieldInternals {
    
    template< class FieldRefType >
    class DoRoutes {
    public:
      typedef typename FieldRefType::node_type node_type;
            
      static void route( node_type *n, Field *f ) {
        FieldRefType::getField( n )->route( f ); 
      }
 
      static void unroute( node_type *n, Field *f ) {
        FieldRefType::getField( n )->unroute( f ); 
      }
    };
        
    template< class FieldRefType, class FieldRefs >
    class DoRoutes< pair< FieldRefType, FieldRefs > > {
    public:
      typedef typename FieldRefType::node_type node_type;       
            
      static void route( node_type *n, Field *f ) {
        FieldRefType::getField( n )->route( f ); 
        DoRoutes< FieldRefs >::route( n , f );
      }
 
      static void unroute( node_type *n, Field *f ) {
        DoRoutes< FieldRefs >::unroute( n , f );
        FieldRefType::getField( n )->unroute( f ); 
      }
    };
 
    class H3DAPI_API EventField: public AutoUpdate< Field > {
    public:
      EventField( Field *f ):
        field( f ) {
        name = "EventField";
      }
 
      virtual void update() {
        field->touch();
      }
      Field *field;
    };
 
    template< class BaseField, class FieldRefs >
    class DependentNodeFieldBase: public BaseField {
    public:
      typedef typename FieldRefs::node_type fr_node_type; 
            
      DependentNodeFieldBase() {
        event_field.reset( new EventField( this ) );
      }
            
      // Constructor.
      //            DependentNodeField( Node *_value ) : 
      //                BaseFieldType( _value ) {
      //                event_field.reset( new EventField( this ) );
      //                }
    protected:
      H3DUniquePtr< EventField > event_field;
    };
 
    template< class BaseField, class FieldRefs, bool DynamicCast = false >
    class DependentNodeField: public DependentNodeFieldBase< BaseField, FieldRefs > {
    protected:
      typedef typename FieldRefs::node_type fr_node_type;
 
      virtual void onAdd( Node *n ) {
        BaseField::onAdd( n );
        fr_node_type *node = static_cast< fr_node_type * >( n );
        if( node )
        DoRoutes< FieldRefs >::route( node,
                                      this->event_field.get() );
      }
            
            
      virtual void onRemove( Node *n ) {
        fr_node_type *node = static_cast< fr_node_type * >( n );
        if( node )
        DoRoutes< FieldRefs >::unroute( node, 
                                        this->event_field.get() );
        BaseField::onRemove( n );
      }
    };
 
    template< class BaseField, class FieldRefs >
    class DependentNodeField< BaseField, FieldRefs, true >: public DependentNodeFieldBase< BaseField, FieldRefs > {
    protected:
      typedef typename FieldRefs::node_type fr_node_type;
 
      virtual void onAdd( Node *n ) {
        BaseField::onAdd( n );
        fr_node_type *node = dynamic_cast< fr_node_type * >( n );
        if( node )
        DoRoutes< FieldRefs >::route( node,
                                      this->event_field.get() );
      }
            
            
      virtual void onRemove( Node *n ) {
        fr_node_type *node = dynamic_cast< fr_node_type * >( n );
        if( node )
        DoRoutes< FieldRefs >::unroute( node, 
                                        this->event_field.get() );
        BaseField::onRemove( n );
      }
    };
  }
  template< class NodeType, class FieldRefs = void, bool DynamicCast = false > 
  class DependentSFNode: 
    public FieldInternals::DependentNodeField< 
    TypedSFNode< NodeType >,
    FieldRefs, DynamicCast > {
  public:
        
    DependentSFNode(){}
 
    virtual ~DependentSFNode(){
      this->value = NULL;
    }
 
  };
 
  template< class FieldRefs, bool DynamicCast > 
  class DependentSFNode< FieldRefs, void, DynamicCast >: 
    public FieldInternals::DependentNodeField< 
    TypedSFNode< typename FieldInternals::DoRoutes< FieldRefs >::node_type >,
    FieldRefs, DynamicCast >  {
  public:
        
    DependentSFNode(){}
    virtual ~DependentSFNode() { 
      this->value = NULL;
    }
 
  };
 
  template< class NodeType, class FieldRefs = void, bool DynamicCast = false > 
  class DependentMFNode: 
    public FieldInternals::DependentNodeField< 
    TypedMFNode< NodeType >,
    FieldRefs,
    DynamicCast > {
  public:
        
    DependentMFNode(){}
      
    virtual ~DependentMFNode(){
      this->clear( this->ownerId() );
    }
 
  };
    
  template< class FieldRefs, bool DynamicCast > 
  class DependentMFNode< FieldRefs, void, DynamicCast >: 
    public FieldInternals::DependentNodeField< 
    TypedMFNode< typename FieldInternals::DoRoutes< FieldRefs >::node_type >,
    FieldRefs,
    DynamicCast >  {
  public:
 
    DependentMFNode(){}
 
    virtual ~DependentMFNode(){
      this->clear( this->ownerId() );
    }
 
  };
 
 
  template< class NodeType, class FieldRefs = void, bool DynamicCast = false > 
  class DependentSFNodeObject:
    public FieldInternals::DependentNodeField<
    TypedSFNodeObject< NodeType >,
    FieldRefs, DynamicCast > {
  public:
        
    DependentSFNodeObject(){}
 
    virtual ~DependentSFNodeObject(){
      this->value = NULL;
    }
 
  };
 
  template< class NodeType, class FieldRefs = void, bool DynamicCast = false > 
  class DependentMFNodeObject:
    public FieldInternals::DependentNodeField<
    TypedMFNodeObject< NodeType >,
    FieldRefs, DynamicCast > {
  public:
        
    DependentMFNodeObject(){}
 
    virtual ~DependentMFNodeObject(){
      this->clear( this->ownerId() );
    }
 
  };
}
 
#endif