PHTypedNodeIterator.h

Go to the documentation of this file.

#ifndef __PHTYPEDNODEITERATOR_H__
#define __PHTYPEDNODEITERATOR_H__
 
#include "PHNodeIterator.h"
 
#include <cstddef>
 
class TObject;
template<typename T> class PHIODataNode;
class PHCompositeNode;
 
//  A special PHOOL node iterator that simplifies finding and adding
//  data nodes.  This version is a templated class, to allow its use
//  interactively in CINT.  (CINT only allows function templates in
//  very recent versions, which we aren't using yet.)
//  @author Kyle Pope
 
template <class T>
class PHTypedNodeIterator : public PHNodeIterator
{
public:
 
  PHTypedNodeIterator(PHCompositeNode* n) : PHNodeIterator(n) { 
    myIODataNode = 0;
  }
 
  PHTypedNodeIterator() : PHNodeIterator() {    
    myIODataNode = 0;
  }
 
  T& operator*();
 
  //  virtual ~PHTypedNodeIterator();  // Need a virtual ~PHNodeIterator() !
  ~PHTypedNodeIterator() {}
 
  PHIODataNode<T>* FindIODataNode(const char* name);
 
  PHIODataNode<T>* find(const char* name);
  
 
  PHBoolean AddIODataNode(T* data, const char* name);
 
  PHBoolean insert(T* data, const char* name);
  
protected:
  PHIODataNode<T>* myIODataNode;  
 
};
 
template <class T>
T&
PHTypedNodeIterator<T>::operator*()
{
  return *(myIODataNode->getData());
}
 
template <class T>
PHIODataNode<T>*
PHTypedNodeIterator<T>::FindIODataNode(const char* name)
{
  return find(name);
}
 
template <class T>
PHIODataNode<T>*
PHTypedNodeIterator<T>::find(const char* name)
{
  // TODO:  also check that "name" is not a null string!
  if (!name) 
    {
      return 0;
    }
 
  // Can't do dynamic_cast here; it fails if node was created as
  // PHIODataNode<X> instead of PHIODataNode<T>, even if T is a
  // derived class of X!  In general, T -> X does not imply A<T> ->
  // A<X>.  ("->" denotes "derives from", and "A" is any template
  // class)
  myIODataNode = 
    static_cast<PHIODataNode<T>*>(findFirst("PHIODataNode", name));
 
  return myIODataNode;
}
 
template <class T>
PHBoolean
PHTypedNodeIterator<T>::AddIODataNode(T* data, const char* name)
{
  return insert(data, name);
}
 
template <class T>
PHBoolean
PHTypedNodeIterator<T>::insert(T* data, const char* name)
{
  // TODO:  also check that "name" is not a null string!
  if (!name)
    {
      return False;
    }
  
  // For IODataNode, ought to check (if possible) that T derives from
  // TObject.  Will typeid() give us this info?
  PHIODataNode<T>* n = new PHIODataNode<T>(data, name);
  if (!n) 
    {
      // problem creating node?
      return False;
    }
 
  return addNode(n);
}
 
// Typedef to simplify notation.
typedef PHTypedNodeIterator<TObject> PHRootNodeIterator;
 
#endif /* __PHTYPEDNODEITERATOR_H__ */