DependentNodeFields.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.
//
//
// \file DependentNodeFields.h Contains the DependentSFNode and 
//
#ifndef __DEPENDENTNODEFIELDS_H__
#define __DEPENDENTNODEFIELDS_H__

#include "SFNode.h"
#include "MFNode.h"

namespace H3D {

  template< class NodeType, 
            class FieldType, 
            auto_ptr< FieldType > NodeType:: *member_ptr >
  class FieldRef {
  public:
    typedef NodeType node_type;
    typedef FieldType field_type;
    typedef auto_ptr< 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 ); 
      }
    };

    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 ) );
      }
            
      //            DependentNodeField( Node *_value ) : 
      //                BaseFieldType( _value ) {
      //                event_field.reset( new EventField( this ) );
      //                }
            
    protected:
      class EventField: public AutoUpdate< Field > {
      public:
        EventField( Field *f ):
          field( f ) {
          name = "EventField";
        }

        virtual void update() {
          field->touch();
        }
        Field *field;
      };
            
      auto_ptr< 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(){}

    ~DependentSFNode(){
      this->value = NULL;
    }

    //        DependentSFNode( Node *_value ) : 
    //            FieldInternals::DependentNodeField< TypedSFNode< NodeType >,
    //                           FieldRefs >( _value ) {}
        
  };

  template< class FieldRefs, bool DynamicCast > 
  class DependentSFNode< FieldRefs, void, DynamicCast >: 
    public FieldInternals::DependentNodeField< 
    TypedSFNode< typename FieldInternals::DoRoutes< FieldRefs >::node_type >,
    FieldRefs, DynamicCast >  {
  public:
        
    DependentSFNode(){}
    ~DependentSFNode(){ 
      this->value = NULL;
    }

    //        DependentSFNode( Node *_value ) : 
    //            FieldInternals::DependentNodeField< 
    //            TypedSFNode< typename DoRoutes< FieldRefs >::node_type >,
    //            FieldRefs >( _value ) {}
        
  };

  template< class NodeType, class FieldRefs = void, bool DynamicCast = false > 
  class DependentMFNode: 
    public FieldInternals::DependentNodeField< 
    TypedMFNode< NodeType >,
    FieldRefs,
    DynamicCast > {
  public:
        
    DependentMFNode(){}
      
    ~DependentMFNode(){
      this->clear( this->ownerId() );
    }

    //        DependentMFNode( MFNode::size_type size ) : 
    //            FieldInternals::DependentNodeField< 
    //            TypedMFNode< typename DoRoutes< FieldRefs >::node_type >,
    //            FieldRefs >( size ){}
  };
    
  template< class FieldRefs, bool DynamicCast > 
  class DependentMFNode< FieldRefs, void, DynamicCast >: 
    public FieldInternals::DependentNodeField< 
    TypedMFNode< typename FieldInternals::DoRoutes< FieldRefs >::node_type >,
    FieldRefs,
    DynamicCast >  {
  public:
        
    DependentMFNode(){}

    ~DependentMFNode(){
      this->clear( this->ownerId() );
    }
        
    //        DependentMFNode( MFNode::size_type size ) : 
    //            FieldInternals::DependentNodeField< 
    //              TypedMFNode< typename FieldInternals::DoRoutes< FieldRefs >::node_type >,
    //            FieldRefs >( size ){}
        
  };
}

#endif

---