Hierarchy.cpp

Go to the documentation of this file.

// $Id: $
// Include files

// local
#include "Hierarchy.h"

//-----------------------------------------------------------------------------
// Implementation file for class : Hierarchy
//
// 2006-10-26 :
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
Hierarchy::Hierarchy(  ) :
  m_parent (0){
  m_origin=this;
}

//=============================================================================
// Destructor
//=============================================================================
Hierarchy::~Hierarchy() {
  if (0!=parent()){
    parent()->delChild(this);
  }
  debug("deleting Hierarchy "+name(),"Hierarchy::~Hierarchy");
}


//=========================================================================
//
//=========================================================================
void Hierarchy::clear(){
  std::vector<Hierarchy*> listlocale;
  std::vector<Hierarchy*>::iterator iter;
  info("loop on "+name()+" children.","Hierarchy::clear");
  for (iter=m_children.begin();iter!=m_children.end();iter++){
      info("processing "+(*iter)->name()+".","Hierarchy::clear");
/*
      (*iter)->clear();
//      this->delChild((*iter));
      info("obj "+(*iter)->name()+" being cleared.","Hierarchy::clear");
      delete (*iter);
      info("Object deleted.","Hierarchy::clear");
      m_children.erase(iter);
      info("Object removed from the tree.","Hierarchy::clear");
*/
    (*iter)->clear();
    info("Adding object "+(*iter)->name()+" from the Hierarchy to the list of deleted objects.","Hierarchy::clear");
    listlocale.push_back((*iter));
  }

  for (iter=listlocale.begin();iter!=listlocale.end();iter++){
    info("Removing object "+(*iter)->name()+".","Hierarchy::clear");
    this->delChild(*iter);
//    m_children.erase(iter);
    delete (*iter);
  }
  info("Getting out of "+name());
}

//=========================================================================
//
//=========================================================================
void Hierarchy::setParent ( Hierarchy* parent ) {
  m_parent = parent;
  if ((Hierarchy*)0==parent) return;

  Hierarchy *curr = this;
  Hierarchy *prev = parent;
  while ( prev != 0 ){
    curr = prev;
    prev = curr->parent();
  }
  if (parent->origin()!=0) m_origin=parent->origin();
}

//=========================================================================
//
//=========================================================================
void Hierarchy::addChild(Hierarchy* element){
  element->setParent(this);
  m_children.push_back(element);
  debug(element->name()+" added to the child tree.","Hierarchy::addChild");
}

//=========================================================================
//
//=========================================================================
void Hierarchy::delChild(Hierarchy* element){
  bool flag=false;
  std::vector<Hierarchy*>::iterator iter,remove;
  for (iter=m_children.begin();(iter!=m_children.end());iter++){
    if (*iter==element){
      remove=iter;
      flag=true;
    }
  }
  if (flag){
    debug("removing "+(*remove)->name()+" from the tree.","Hierarchy::delChild");
    m_children.erase(remove);
  }
}

//=========================================================================
//
//=========================================================================
void Hierarchy::delChild(std::string n){
  bool flag=false;
  std::vector<Hierarchy*>::iterator iter,remove;
  for (iter=m_children.begin();iter!=m_children.end();iter++){
    if ((*iter)->name()==n){ remove=iter; flag=true;}
  }
  if (flag){
    debug("removing "+(*remove)->name()+" from the tree.","Hierarchy::delChild");
    m_children.erase(remove);
  }
}

//=========================================================================
//
//=========================================================================
unsigned long Hierarchy::numberOfChildren ( ){
  return m_children.size();
}


//=========================================================================
//
//=========================================================================
Hierarchy* Hierarchy::child(std::string path){
  std::string newpath = path;
  std::string up("..");
  std::string separator(1,'/');

  Hierarchy * newcurrent = 0;

  //  info("path="+path,"Hierarchy::child");

  if (path.compare("")==0 || path.compare("/")==0) {
    //    debug("return origin","Hierarchy::child");
    return origin();
  }

  if (path.compare(name())==0){
    //    debug("return itself","Hierarchy::child");
    return this;
  }

  if (path.compare("..")==0){
    if (0!=this->parent()) return this->parent();
    else return this;
  }

  if (path.compare("../")==0){
    if (0!=this->parent()) return this->parent();
    else return this;
  }


  int npos=path.find(separator,0);

  //  info("find separator in "+itos(npos)+" of "+path,"Hierarchy::child");

  // remove last separator
  if ( npos == (int)(path.size()-1) ) {
    newpath = std::string(path,0,npos);
    path = newpath;
  }

  if (npos==0){
    //    debug("Going back to origin and calling child","Hierarchy::child");
    newpath=std::string(path,1,path.size()-1);
    return origin()->child(newpath);
  }
  else{
    if ( npos== (int)(std::string::npos) ){
      //      debug("Getting chid "+path+" of "+this->name(),"Hierarchy::child");
      std::vector <Hierarchy*> list = children();
      std::vector<Hierarchy*>::iterator iter;
      for (iter=list.begin();iter!=list.end();iter++){
        if ((*iter)->name().compare(path)==0){
          return *iter;
        }
      }
      warning(this->name()+std::string(" has no child '")+path+"'","Hierarchy::child");
      return this;
    }
    else
    {
      int ipos=path.find(separator,0);
      //      info("default behaviour "+path+" with separator in "+itos(ipos),"Hierarchy::child");

      std::string newcurrentname=std::string(path,0,ipos);
      newpath=std::string(path,ipos+1,path.size()-1);

      //      info("looking now for "+newpath+" from "+newcurrentname,"Hierarchy::child");

      if (0==newcurrentname.compare(origin()->name())){
        //        info("current is computer. Looking for children"+newcurrentname,"Hierarchy::child");
        return origin()->child(newpath);
      }

      newcurrent = (Hierarchy*)0;

      std::vector <Hierarchy*> list = children();
      std::vector<Hierarchy*>::iterator iter;
      for (iter=list.begin();iter!=list.end();iter++){
        if ((*iter)->name().compare(newcurrentname)==0){
          newcurrent = (*iter);
        }
      }


      if ((Hierarchy*)0==newcurrent){
        if (newcurrentname.compare("..")==0 && 0!=parent()){
          newcurrent=this->parent();
          //          debug("newcurrent was .. -> parent="+parent()->name());
        }
        else
        {
          warning(this->name()+" has no child '"+newcurrentname+"'",
              "Hierarchy::child");
          return this;
        }
      }
      //      debug("recurrence call for "+newpath+" on "+newcurrent->name(),"Hierarchy::child");
      return newcurrent -> child ( newpath );
    }
  }
}


//=========================================================================
//
//=========================================================================
Hierarchy* Hierarchy::childTyped(std::string path){

  std::string newpath = path;

  std::string up("..");
  std::string separator(1,'/');
  std::string typeopen(1,'[');
  std::string typeclose(1,']');

  Hierarchy * newcurrent = 0;

  unsigned int npos=path.find(separator,0);
  unsigned int opos=path.find(typeopen,0);
  if ( npos==std::string::npos || npos == path.size()-1 ){
    if ( path.compare("..")==0 ) {
      return parent();
    }

    if ( npos == path.size()-1 ) {
      newpath = std::string(path,0,opos);
      path = newpath;
    }

    std::vector < Hierarchy* > list = children();
    std::vector < Hierarchy* >::iterator iter;
    for (iter=list.begin();iter!=list.end();iter++){
      std::string notypepath = std::string(path,0,opos);
      if ((*iter)->name().compare(notypepath)==0){
        return *iter;
      }
    }
    warning(this->name()+std::string(" has no child ") +path,"Hierarchy::child");
    return 0;
  }

  else {

    if (std::string(path,0,3).compare(std::string("../"))==0) {
      newpath=std::string(path,3,path.size()-3);
      newcurrent = parent();
    }
    if (std::string(path,0,1).compare(std::string("/"))==0) {
      newpath=std::string(path,1,path.size()-1);
      newcurrent = ( Hierarchy* ) m_origin;
    }
    if ((std::string(path,0,3).compare(std::string("../")) !=0 ) &&
        std::string(path,0,1).compare(std::string("/"))!=0 ) {
      opos = path.find(typeopen,0);
      int cpos = path.find(typeclose,0);
      std::string name = std::string (path,0,opos);
      newcurrent = childTyped( name );
      if (newcurrent ==0){
        warning(path+": no child found with such a name","Hierarchy::child");
      }
      newpath = std::string (path,cpos+2,path.size()-cpos-1);
    }
    return newcurrent -> childTyped ( newpath );
  }
}


//=========================================================================
//
//=========================================================================
bool Hierarchy::hasChildren ( ) {
  return ( m_children.size()>0 );
}

//=========================================================================
//
//=========================================================================
void Hierarchy::tree(std::string indent){
  std::string line=indent+" -> "+name()+"["+type()+"] ";
  if (std::string("")==indent){
    info("Hierarchy for Object "+name()+"["+type()+"]","Hierarchy::tree");
  }
  msgSvc(MsgSvc::NONE,line,"");
  std::vector<Hierarchy*> list = children();
  std::vector<Hierarchy*>::iterator iter;
  for (iter=list.begin() ; iter!=list.end() ; ++iter){
    std::string tab="  ";
    (*iter)->tree(indent+tab);
  }
}

//=========================================================================
//
//=========================================================================
Hierarchy* Hierarchy::parent( std::string type ){
  Hierarchy *parent = this->parent();
  if ( 0 != parent){
    if (parent->type().compare( type )==0) {
      return parent;
    }
    else
      return parent->parent( type );
  }
  else {
    return (Hierarchy*)NULL;
  }
}

//=========================================================================
//
//=========================================================================
std::string Hierarchy::path(std::string str){
  str="/"+name()+str;
  Hierarchy *m_parent=parent();
  if (0!=m_parent){
    return m_parent->path(str);
  }
  return str;
}

//=========================================================================
//
//=========================================================================
std::string Hierarchy::pathTyped(std::string str){
  Hierarchy *m_parent=parent();
  if (0!=m_parent){
    str="/"+name()+"["+type()+"]"+str;
    return m_parent->pathTyped(str);
  }
  return str;
}

//=============================================================================