StiCompositeTreeNode.h

//StiCompositeTreeNode                        
//M.L. Miller (Yale Software)
//07/01

#ifndef StiCompositeTreeNode_H
#define StiCompositeTreeNode_H

#include "Stiostream.h"
#include <iterator>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

/*
  using std::find;
  using std::vector;
  using std::string;
  using std::cout;
  using std::ostream;
  using std::endl;
*/

struct StiOrderKey
{
    StiOrderKey() 
        : key(0.), index(0) {};
    StiOrderKey(double k, unsigned int i) 
        : key(k), index(i) {};
    
    double key;
    unsigned int index;
};

template <class T>
class StiCompositeTreeNode
{
public:

    StiCompositeTreeNode();

    virtual ~StiCompositeTreeNode();
    
    //Sets
    void reset(){;}
    void unset(){;}

    void setName(const string&);

    void setOrderKey(const StiOrderKey&);

    void setData(T*);
    
    //Gets

    const string& getName() const;

    unsigned int getChildCount() const;

    StiCompositeTreeNode* getParent() const;

    const StiOrderKey& getOrderKey() const;

    T* getData() const;
    
    //Action

    virtual void add(StiCompositeTreeNode*);
    
public:
    //provide random access iterators to daughters

    typedef vector<StiCompositeTreeNode *> vec_type;
    
    typedef vector<StiCompositeTreeNode *> StiCompositeTreeNodeVector;

    typename vec_type::iterator whereInParent() {
        return (mparent) ? (mparent->begin()+mkey.index) : mVec.end();
    }

    typename vec_type::iterator begin() {return mVec.begin();}
        
    typename vec_type::iterator end() {return mVec.end();}

    typename vec_type::const_iterator begin() const {return mVec.begin();}
    
    typename vec_type::const_iterator end() const {return mVec.end();}

    typename vec_type::reverse_iterator rbegin() {return mVec.rbegin();}
    
    typename vec_type::reverse_iterator rend() {return mVec.rend();}

    typename vec_type::const_reverse_iterator rbegin() const {return mVec.rbegin();}
    
    typename vec_type::const_reverse_iterator rend() const {return mVec.rend();}
    
private:

    void setParent(StiCompositeTreeNode* val);

    vec_type mVec;

    StiCompositeTreeNode* mparent;

    T* mdata;

    StiOrderKey mkey;

    string mname;
};

//Implementation

template <class T>
StiCompositeTreeNode<T>::StiCompositeTreeNode()
    : mparent(0), mdata(0)
{
    mkey.key=0.;
    mkey.index=0;
}

template <class T>
StiCompositeTreeNode<T>::~StiCompositeTreeNode()
{
}

template <class T>
inline void StiCompositeTreeNode<T>::setName(const string& val) 
{
    mname = val;
}

template <class T>
inline void StiCompositeTreeNode<T>::setOrderKey(const StiOrderKey& val)
{
    mkey=val;
}

template <class T>
inline void StiCompositeTreeNode<T>::setData(T* val) 
{
    assert(!mdata);
    mdata=val;
}

template <class T>
inline const string& StiCompositeTreeNode<T>::getName() const 
{
    return mname;
}

template <class T>
inline unsigned int StiCompositeTreeNode<T>::getChildCount() const
{
    return mVec.size();
}

template <class T>
inline StiCompositeTreeNode<T>*
StiCompositeTreeNode<T>::getParent() const 
{
    return mparent;
}

template <class T>
inline const StiOrderKey& StiCompositeTreeNode<T>::getOrderKey() const 
{
    return mkey;
}

template <class T>
inline T* StiCompositeTreeNode<T>::getData() const
{
    return mdata;
}

template <class T>
void StiCompositeTreeNode<T>::add(StiCompositeTreeNode* newChild) 
{
    if (!newChild) return;
    typename StiCompositeTreeNodeVector::iterator where = find(mVec.begin(), mVec.end(),
                                                      newChild);
    //Remove if we see an efficiency penalty
    if (where!=end()) {
        cout <<"StiCompositeTreeNode::add().  ERROR:\t";
        cout <<"Child Already exists.  Abort"<<endl;
        return;
    }
    //else add to list, set parent
    newChild->setParent(this);
    mVec.push_back(newChild);
}

template <class T>
inline void StiCompositeTreeNode<T>::setParent(StiCompositeTreeNode* val) 
{
    if (mparent) {
        cout <<"StiCompositeTreeNode::setParent()\tError:\t";
        cout <<"parent already exists"<<endl;
        return;
    }
    mparent=val;
    return;
}

// \warning This iterator makes no sense for nodes with no parent.  In

/* \warning This iterator makes no sense for nodes with no parent.  In 
  that case whereInParent() returns end().  Therefore, a safe call to whereInParent() 
  would be as follows: <code> \n
  StiCompositeTreeNode<T>::vec_type::iterator where = node->whereInParent(); \n
  if (where!=node->end()) {\\you're ok \n
  }
  <\code>
  
  template <class T>
  StiCompositeTreeNode<T>::vec_type::iterator //return type
  StiCompositeTreeNode<T>::whereInParent()
  {
  return (mparent) ? (mparent->begin()+mkey.index) : mVec.end();
  }
  
  template <class T>
  StiCompositeTreeNode<T>::vec_type::iterator //return type
  StiCompositeTreeNode<T>::begin()
  {
  return mVec.begin();
  }

  template <class T>
  StiCompositeTreeNode<T>::vec_type::iterator //return type
  StiCompositeTreeNode<T>::end()
  {
  return mVec.end();
  }
  
  template <class T>
  StiCompositeTreeNode<T>::vec_type::const_iterator //return type
  StiCompositeTreeNode<T>::begin() const
  {
  return mVec.begin();
  }

  template <class T>
  StiCompositeTreeNode<T>::vec_type::const_iterator //return type
  StiCompositeTreeNode<T>::end() const
  {
  return mVec.end();
  }
  
  template <class T>
  StiCompositeTreeNode<T>::vec_type::reverse_iterator //return type
  StiCompositeTreeNode<T>::rbegin()
  {
  return mVec.rbegin();
  }

  template <class T>
  StiCompositeTreeNode<T>::vec_type::reverse_iterator //return type
  StiCompositeTreeNode<T>::rend()
  {
  return mVec.rend();
  }
  
  template <class T>
  StiCompositeTreeNode<T>::vec_type::const_reverse_iterator //return type
  StiCompositeTreeNode<T>::rbegin() const
  {
  return mVec.rbegin();
  }
  
  template <class T>
  StiCompositeTreeNode<T>::vec_type::const_reverse_iterator //return type
  StiCompositeTreeNode<T>::rend() const
  {
  return mVec.rend();
  }
*/

//For now, include some typdefs that will make for easy user includes
#include "StiDetector.h"
typedef StiDetector data_t;

#ifndef __CINT__
typedef StiCompositeTreeNode<StiDetector> StiDetectorNode;
#else
class StiDetectorNode;
#endif
typedef vector<StiDetectorNode*> StiDetectorNodeVector;

//non-members
inline ostream& operator<<(ostream& os, const StiOrderKey& theKey)
{
        return os<<"key: "<<theKey.key<<" index: "<<theKey.index;
}

#endif