DEFNodes.h

Go to the documentation of this file.

//    H3D API.   Copyright 2004, Danel Evestedt, Mark Dixon
//    All Rights Reserved
//
//

#ifndef __DEFNODES_H__
#define __DEFNODES_H__

#include "Exception.h"
#include "Node.h"
#include <map>
#include <string>

using namespace std;

namespace H3D {
  namespace X3D {
    H3D_VALUE_EXCEPTION( const string, InvalidNodeType );

    H3D_VALUE_EXCEPTION( const string, NoSuchDEFName );

    class H3DAPI_API DEFNodes : 
      private map< const string, Node * > { //, Util::LtStr > {
    public: 
      
      ~DEFNodes() {
                  for( iterator i = map< const string, Node * >::begin(); 
                           i != map< const string, Node * >::end(); 
                           i++ ) {
          (*i).second->unref();
        }
      }
      
      typedef  map< const string, Node * >::const_iterator const_iterator;

      const_iterator begin() {
        return map< const string, Node * >::begin();
      }

      const_iterator end() {
        return map< const string, Node * >::end();
      }

      void addNode( const string &def_name, Node *def_node ) {
        iterator i = find( def_name );
        // increase the reference counter for the new node
        def_node->ref();
        if( i == end() ) {
          insert( make_pair( def_name, def_node ) );
        } else {
          // the def name already exists in the map. Since the node
          // that is there will be overwritten we unref it.
          (*i).second->unref();
          (*i).second = def_node;
        }
      }

      void removeNode( const string& def_name ) {
        iterator i = find( def_name );
        if( i == end() ) {
          throw X3D::NoSuchDEFName( def_name );
        } else {
          // unref the node that is removed
          (*i).second->unref();
          erase( i );
        }
      }

      void merge( DEFNodes *dn ) {
        if( dn ) {
          for( const_iterator i = dn->begin(); i != dn->end(); i++ )
            addNode( (*i).first, (*i).second );
        }
      }

      void clear() {
        for( const_iterator i = begin(); i != end(); i++ )
          // unref the node that is removed
          (*i).second->unref();
        map< const string, Node * >::clear();
      }

      Node *getNode( const string &def_name ) {
        iterator i = find( def_name );
        if( i == end() ) {
          return NULL; //throw Exception::NoSuchDEFNameInX3D( def_name, "getNode()" );
        } else {
          return (*i).second;
        }
      }

      template< class NodeType >
      void getNode( const string &def_name, 
                    NodeType *&return_node ) {
        Node *node = getNode( def_name ) ;
        NodeType *n = dynamic_cast< NodeType * >( node );
        if( node && !n ) {
          stringstream msg;
          msg << "DEFNodes::getNode (expecting " 
              << typeid( NodeType ).name() 
              << ")";
          throw InvalidNodeType( typeid( *node ).name(), 
                                 msg.str() );
        }
        return_node = n;
      }; 
      
    };
  }
}

#endif

---