RefCountSField.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 __REFCOUNTSFIELD_H__
#define __REFCOUNTSFIELD_H__

#include "AutoRef.h"
#include "RefCountedClass.h"
#include "Field.h"

namespace H3D {

  template< class RefClass, class BaseField = H3D::Field >
  class RefCountSField: public BaseField {
  public: 
    typedef RefClass typed_class_type;
    typedef RefClass * typed_value_type;
    typedef RefClass class_type;
    typedef RefClass * value_type;
    
    RefCountSField(): value( NULL ) {
      value.rc_field = this;
    };
      
    RefCountSField( RefClass *_value ) : value( _value ) {
      value.rc_field = this;
    }
      
    inline virtual void setValue( const AutoRef< RefClass > &n, int id = 0 );
      
    inline virtual void setValue( RefClass *n, int id = 0 );
      
    inline virtual RefClass *getValue( int id = 0 );
      
  protected:
    inline virtual void update();
      
    virtual RefClass *preOnAdd( RefClass *n ) {
      return n;
    }
    
    virtual RefClass *preOnRemove( RefClass *n ) {
      return n;
    }

    class RefCountSFieldAutoRef: public AutoRef< RefClass > {
    public :

      explicit RefCountSFieldAutoRef( RefClass* n = 0) throw() :
        AutoRef< RefClass >( n ) {
    
      }

      RefCountSFieldAutoRef& operator=(RefClass* n) throw() {
        this->reset( n );
        return *this;
      }
  
      template< class RefClassClass >
      RefCountSFieldAutoRef& operator=(const AutoRef<RefClassClass> &n) 
        throw() {
        this->reset( n.get() );
        return *this;
      }
  
      ~RefCountSFieldAutoRef() throw() {
        this->reset( NULL );
      } 
  
      inline virtual void ref( RefClass *n ) {
        if( rc_field && n ) {
          AutoRef< RefClass >::ref( n );
          rc_field->onAdd( rc_field->preOnAdd( n ) );
        }
      }
  
      inline virtual void unref( RefClass *n ) {
        if( rc_field && n ) {
          rc_field->onRemove( rc_field->preOnRemove( n ) );
          AutoRef< RefClass >::unref( n );
        }
      }
      RefCountSField *rc_field;
    };
      
    friend class RefCountSFieldAutoRefVector;
      
    virtual void onAdd( RefClass *n ) {
#ifdef REF_COUNT_DEBUG
      Console(1) << "RefCountSField: Add node" << endl;
#endif
    }
      
    virtual void onRemove( RefClass *n ) {
#ifdef REF_COUNT_DEBUG
      Console(1) << "RefCountSField: Remove node" << endl;
#endif
    }
      
    RefCountSFieldAutoRef value;
  };
  
  template< class RefClass, class BaseField >
  void RefCountSField< RefClass, BaseField >::update() {
#ifdef REF_COUNT_DEBUG
    Console(1) << "RefCountSField(" << name << ")::update()   event_ptr = " 
               << event.ptr << endl;
#endif
    value = static_cast< RefCountSField* >(this->event.ptr)->getValue();
    
  }
  
  template< class RefClass, class BaseField >
  inline void RefCountSField< RefClass, BaseField >::setValue( RefClass *n,
                                                               int id ) {
    this->checkAccessTypeSet( id );
#ifdef REF_COUNT_DEBUG
    Console(1) << "RefCountSField(" << name << ")::setValue()" << endl;
#endif
    value = n;
    // generate an event.
    this->startEvent();
  }
  
  template< class RefClass, class BaseField >
  void RefCountSField< RefClass, BaseField >::setValue( 
                                             const AutoRef< RefClass > &n,
                                             int id ) {
    this->setValue( n.get(), id );
  }
  
  template< class RefClass, class BaseField >
  RefClass *RefCountSField< RefClass, BaseField >::getValue( int id ) {
#ifdef REF_COUNT_DEBUG
    Console(1) << "RefCountSField(" <<  name << ")::getValue()" << endl;
#endif
    this->checkAccessTypeGet( id );
    // check that the field is up-to-date first
    this->upToDate();
    return value.get();
  }
  
}

#endif

---