AutoRefVector.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 __AUTOREFVECTOR_H__
#define __AUTOREFVECTOR_H__

#include "H3DApi.h"
#include <vector>
#include <algorithm>

using namespace std;

namespace H3D {
  template< class NodeClass >
  class AutoRefVector : private vector<NodeClass*> {
  public:
    typedef typename vector<NodeClass*>::value_type value_type;
    typedef typename vector<NodeClass*>::pointer pointer;
    typedef typename vector<NodeClass*>::const_reference const_reference;
    typedef typename vector<NodeClass*>::size_type size_type;
    typedef typename vector<NodeClass*>::difference_type difference_type; 
    typedef typename vector<NodeClass*>::const_iterator const_iterator;
    typedef typename vector<NodeClass*>::const_reverse_iterator 
    const_reverse_iterator;

    inline AutoRefVector() {}

    inline AutoRefVector( const vector<NodeClass *> &v ) : 
      vector<NodeClass*>( v ) {
      refAll();
    }

    inline AutoRefVector( const AutoRefVector<NodeClass> &v ) : 
      vector<NodeClass*>( v ) {
      refAll();
    }

    inline AutoRefVector( size_type n ):
      vector< NodeClass * >( n ) {}

    inline virtual ~AutoRefVector() {
      clear();
    }

    inline AutoRefVector<NodeClass> 
    &operator=( const AutoRefVector<NodeClass> &v ) {
      if( this != &v ) {
        unrefAll();      
        vector<NodeClass*>::operator=( v );
        refAll();
      }
      return *this;
    }

    inline AutoRefVector<NodeClass> &operator=( 
                                               const vector<NodeClass *> &v ) {
      // temporarily add an extra reference to the nodes in v so
      // they are not accidentally removed in unrefAll()
      for( typename vector< NodeClass * >::const_iterator i = v.begin();
           i != v.end();
           i++ ) 
        (*i)->ref();
      unrefAll();
      vector<NodeClass*>::operator=( v );
      refAll();

      // remove the temporary references.
      for( typename vector< NodeClass * >::const_iterator i = v.begin();
           i != v.end();
           i++ ) 
        (*i)->unref();
      return *this;
    }

    inline const_iterator begin() const { 
      return vector<NodeClass*>::begin();
    }
      
    inline const_iterator end() const { return vector<NodeClass*>::end(); }

        
    inline const_reverse_iterator rbegin() const { 
      return vector<NodeClass*>::rbegin();
    }
      
    inline const_reverse_iterator rend() const { 
      return vector<NodeClass*>::rend(); 
    }

    inline size_type size() const { 
      return vector<NodeClass*>::size(); 
    }

    inline size_type max_size() const {
      return vector<NodeClass*>::max_size();
    }
        
    inline size_type capacity() const { 
      return vector<NodeClass*>::capacity(); 
    }
        
    inline void swap( AutoRefVector<NodeClass> &x ) {
      vector<NodeClass*>::swap( x );
    }

    inline void swap( vector<NodeClass*> &x ) {
      unrefAll();
      vector<NodeClass*>::swap( x );
      refAll();
    }
        
    inline void reserve( size_t s ) { vector<NodeClass*>::reserve( s ); }

    inline virtual void resize( size_t n, NodeClass * t = NULL ) {
      if( size() > n ) {
        for( unsigned int i = size() - 1; i >= n; i-- )
          unref( vector<NodeClass*>::operator[]( i ) );
      }
      vector<NodeClass*>::resize( n, t );
    }

    inline bool empty() const { return vector<NodeClass*>::empty(); }
    inline const_reference operator[](size_type n) const {
      return vector<NodeClass*>::operator[]( n );
    }
    inline void set( size_type i, const value_type &v ) {
      vector<NodeClass*>::operator[]( i ) = v;
    }
    inline const_reference front() const { return vector<NodeClass*>::front(); }

    inline const_reference back() const { return vector<NodeClass*>::back(); }

    inline void push_back( const value_type &x ) {
      ref( x );
      vector< NodeClass * >::push_back( x );
    }

    void pop_back() {
      unref( back() );
      vector< NodeClass * >::pop_back();
    }
        
    inline void clear() {
      unrefAll();
      vector<NodeClass*>::clear();
    }

    inline virtual void erase( NodeClass *a ) {
      typename vector<NodeClass * >::iterator i = 
        std::find( vector<NodeClass*>::begin(), 
                   vector<NodeClass*>::end(), 
                   a );
      if( i != end() ) {
        unref( *i );
        vector<NodeClass*>::erase( i );
      } 
    }

  protected:
    inline virtual void ref( NodeClass *n ) const {
      if( n ) {
        n->ref();
      }
    }

    inline virtual void unref( NodeClass *n ) const {
      if( n ) {
        n->unref();
      }
    }

    inline void refAll() const {
      for( const_iterator i = vector<NodeClass*>::begin(); 
           i != vector<NodeClass*>::end(); ++i ) 
        ref( *i );
    }

    inline void unrefAll() const {
      for( const_iterator i = vector<NodeClass*>::begin(); 
           i != vector<NodeClass*>::end(); ++i ) 
        unref( *i );
    }
  };
}
    
#endif

---