#include <inc/Hierarchy.h>

Inheritance diagram for Hierarchy:

Public Member Functions
	Hierarchy ()
	Standard constructor. More...

virtual	~Hierarchy ()
	Destructor. More...

void	clear ()

void	setParent (Hierarchy *parent)

Hierarchy *	parent ()

Hierarchy *	parent (std::string)

Hierarchy *	origin ()

virtual void	addChild (Hierarchy *element)

std::vector< Hierarchy * >	children ()

Hierarchy *	child (std::string)

Hierarchy *	childTyped (std::string)

unsigned long	numberOfChildren ()

bool	hasChildren ()

void	delChild (Hierarchy *)

void	delChild (std::string)

std::string	path (std::string=std::string(""))

std::string	pathTyped (std::string=std::string(""))

void	tree (std::string indent=std::string(""))

void	tree ()

Public Member Functions inherited from Object
	Object ()
	Standard constructor. More...

virtual	~Object ()
	Destructor. More...

std::string	name () const

std::string	type ()

unsigned char	id ()

std::string	title ()

void	msgSvc (int level, std::string msg, std::string name)

void	msg (std::string mymsg)

void	verbose (std::string mymsg)

void	debug (std::string mymsg)

void	info (std::string mymsg)

void	warning (std::string mymsg)

void	error (std::string mymsg)

void	fatal (std::string mymsg)

void	msg (std::string mymsg, std::string name)

void	verbose (std::string mymsg, std::string name)

void	debug (std::string mymsg, std::string name)

void	info (std::string mymsg, std::string name)

void	warning (std::string mymsg, std::string name)

void	error (std::string mymsg, std::string name)

void	fatal (std::string mymsg, std::string name)

void	setName (std::string name)

void	setType (std::string type)

void	setId (unsigned char id)

void	setTitle (std::string title)

void	setDllName (std::string dllName)

std::string	dllName ()

Public Member Functions inherited from Attrib
	Attrib ()
	Standard constructor. More...

virtual	~Attrib ()
	Destructor. More...

bool	is (int attribut)

void	add (int attribut)

void	remove (int attribut)

std::string	attributs ()

Private Attributes
Hierarchy *	m_parent

Hierarchy *	m_origin

std::vector< Hierarchy * >	m_children

Additional Inherited Members
Public Types inherited from Attrib
enum	Attribut { UNDEFINED, PASSIVE, ACTIVE, INTERFACE, IO, IODATA, ELEMENT, HARDWARE, PROCESSUS, SOFTWARE }

Protected Attributes inherited from Attrib
std::string	m_attribString [10]

Detailed Description

Class to define an Element Hierarchy

Author

Date: 2006-10-26

Definition at line 19 of file Hierarchy.h.

Constructor & Destructor Documentation

◆ Hierarchy()

Hierarchy::Hierarchy ( )

Standard constructor.

Definition at line 16 of file Hierarchy.cpp.

References m_origin.

                        :
   m_parent (0){
   m_origin=this;
 }

◆ ~Hierarchy()

Hierarchy::~Hierarchy ( )

virtual

Destructor.

Definition at line 24 of file Hierarchy.cpp.

References Object::debug(), delChild(), Object::name(), and parent().

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

Member Function Documentation

◆ addChild()

void Hierarchy::addChild ( Hierarchy * element )

virtual

Definition at line 83 of file Hierarchy.cpp.

References Object::debug(), m_children, Object::name(), and setParent().

Referenced by A3PE::A3PE(), SpecsMezzanine::addBus(), SpecsSlave::addI2c(), Application::create(), CU_v1::CU_v1(), export_obj(), FEB_v1::FEB_v1(), FePGA::FePGA(), ICECALv3::ICECALv3(), ICPhaser::ICPhaser(), FePGA::MakeRAM(), FePGA::MakeRegister(), origin(), Phaser::Phaser(), Proto40MHz_v1::Proto40MHz_v1(), SeqPGA::SeqPGA(), SpecsMezzanine::SpecsMezzanine(), UsbI2cBus::UsbI2cBus(), and UsbSpiBus::UsbSpiBus().

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

◆ child()

Hierarchy * Hierarchy::child ( std::string path )

Definition at line 133 of file Hierarchy.cpp.

References child(), children(), Object::name(), origin(), parent(), path(), and Object::warning().

Referenced by Application::cd(), child(), children(), and export_obj().

                                          {
   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 );
     }
   }
 }

◆ children()

std::vector<Hierarchy*> Hierarchy::children ( )

inline

Definition at line 33 of file Hierarchy.h.

References child(), childTyped(), delChild(), hasChildren(), m_children, numberOfChildren(), path(), pathTyped(), and tree().

Referenced by child(), childTyped(), export_obj(), SpecsSlave::recursiveInitCommunications(), Element::recursiveInitCommunications(), Element::recursiveInitElement(), Application::setConfig(), and tree().

33 { return m_children; } //< get list of child(ren)

Hierarchy::m_children

std::vector< Hierarchy * > m_children

Definition: Hierarchy.h:53

◆ childTyped()

Hierarchy * Hierarchy::childTyped ( std::string path )

Definition at line 239 of file Hierarchy.cpp.

References children(), m_origin, Object::name(), parent(), path(), and Object::warning().

Referenced by children(), and export_obj().

                                               {
 
   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 );
   }
 }

◆ clear()

void Hierarchy::clear ( )

Definition at line 35 of file Hierarchy.cpp.

References delChild(), Object::info(), m_children, and Object::name().

Referenced by export_obj().

                      {
   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());
 }

◆ delChild() [1/2]

void Hierarchy::delChild ( Hierarchy * element )

Definition at line 92 of file Hierarchy.cpp.

References Object::debug(), and m_children.

Referenced by children(), clear(), export_obj(), and ~Hierarchy().

                                           {
   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);
   }
 }

◆ delChild() [2/2]

void Hierarchy::delChild ( std::string n )

Definition at line 110 of file Hierarchy.cpp.

References Object::debug(), and m_children.

                                    {
   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);
   }
 }

◆ hasChildren()

bool Hierarchy::hasChildren ( )

Definition at line 303 of file Hierarchy.cpp.

References m_children.

Referenced by children(), and export_obj().

                               {
   return ( m_children.size()>0 );
 }

◆ numberOfChildren()

unsigned long Hierarchy::numberOfChildren ( )

Definition at line 125 of file Hierarchy.cpp.

References m_children.

Referenced by children(), and export_obj().

                                            {
   return m_children.size();
 }

◆ origin()

Hierarchy* Hierarchy::origin ( )

inline

Definition at line 30 of file Hierarchy.h.

References addChild(), and m_origin.

Referenced by child(), export_obj(), and setParent().

30 { return m_origin; } //< Get the origin of the tree

Hierarchy::m_origin

Hierarchy * m_origin

Definition: Hierarchy.h:52

◆ parent() [1/2]

Hierarchy* Hierarchy::parent ( )

inline

Definition at line 28 of file Hierarchy.h.

References m_parent.

Referenced by child(), childTyped(), export_obj(), UsbMLSpiBus::init(), UsbMLI2cBus::init(), UsbI2cBus::init(), UsbSpiBus::init(), IOobject::init(), parent(), path(), pathTyped(), Element::setConnection(), setParent(), SpecsInterface::specsMaster(), SpecsInterface::specsMasterDevice(), SpecsInterface::specsSlave(), SpecsInterface::specsSlaveDevice(), and ~Hierarchy().

28 { return m_parent; } //< Get Hierarchy Parent

Hierarchy::m_parent

Hierarchy * m_parent

Definition: Hierarchy.h:46

◆ parent() [2/2]

Hierarchy * Hierarchy::parent ( std::string type )

Definition at line 327 of file Hierarchy.cpp.

References parent(), and Object::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;
   }
 }

◆ path()

std::string Hierarchy::path ( std::string str = std::string("") )

Definition at line 344 of file Hierarchy.cpp.

References m_parent, Object::name(), parent(), and path().

Referenced by child(), children(), childTyped(), export_obj(), path(), UsbFTMLInterface::usbReadU16(), UsbFTMLInterface::usbReadU32(), UsbFTMLInterface::usbReadU8(), UsbFTMLInterface::usbWriteRead(), UsbFTMLInterface::usbWriteU16(), UsbFTMLInterface::usbWriteU32(), and UsbFTMLInterface::usbWriteU8().

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

◆ pathTyped()

std::string Hierarchy::pathTyped ( std::string str = std::string("") )

Definition at line 356 of file Hierarchy.cpp.

References m_parent, Object::name(), parent(), pathTyped(), and Object::type().

Referenced by children(), export_obj(), and pathTyped().

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

◆ setParent()

void Hierarchy::setParent ( Hierarchy * parent )

Definition at line 67 of file Hierarchy.cpp.

References m_origin, m_parent, origin(), and parent().

Referenced by SpecsMezzanine::addBus(), addChild(), SpecsSlave::addI2c(), Computer::Computer(), Application::create(), export_obj(), and SpecsMezzanine::SpecsMezzanine().

                                               {
   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();
 }

◆ tree() [1/2]

void Hierarchy::tree ( std::string indent = std::string("") )

Definition at line 310 of file Hierarchy.cpp.

References children(), Object::info(), Object::msgSvc(), Object::name(), MsgSvc::NONE, and Object::type().

                                     {
   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);
   }
 }

◆ tree() [2/2]

void Hierarchy::tree ( )

inline

Definition at line 46 of file Hierarchy.h.

References m_parent, and tree().

Referenced by children(), export_obj(), and tree().

46 { tree(""); }; // output tree of Hierarchy from object

Hierarchy::tree

void tree()

Definition: Hierarchy.h:46

Member Data Documentation

◆ m_children

std::vector<Hierarchy*> Hierarchy::m_children

private

Definition at line 53 of file Hierarchy.h.

Referenced by addChild(), children(), clear(), delChild(), hasChildren(), and numberOfChildren().

◆ m_origin

Hierarchy* Hierarchy::m_origin

private

Definition at line 52 of file Hierarchy.h.

Referenced by childTyped(), Hierarchy(), origin(), and setParent().

◆ m_parent

Hierarchy* Hierarchy::m_parent

private

Definition at line 46 of file Hierarchy.h.

Referenced by parent(), path(), pathTyped(), setParent(), and tree().

The documentation for this class was generated from the following files:

/home/eleclhcb/LHCb/lbcat-cmake/CatKernel/inc/Hierarchy.h
/home/eleclhcb/LHCb/lbcat-cmake/CatKernel/src/Hierarchy.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Hierarchy()

◆ ~Hierarchy()

Member Function Documentation

◆ addChild()

◆ child()

◆ children()

◆ childTyped()

◆ clear()

◆ delChild() [1/2]

◆ delChild() [2/2]

◆ hasChildren()

◆ numberOfChildren()

◆ origin()

◆ parent() [1/2]

◆ parent() [2/2]

◆ path()

◆ pathTyped()

◆ setParent()

◆ tree() [1/2]

◆ tree() [2/2]

Member Data Documentation

◆ m_children

◆ m_origin

◆ m_parent