tools::aida::base_looper< T > Class Template Reference

Inheritance diagram for tools::aida::base_looper< T >:

Collaboration diagram for tools::aida::base_looper< T >:

Public Member Functions
	base_looper (base_ntu &a_ntu, const base_col &a_col)
virtual	~base_looper ()
	base_looper (const base_looper &a_from)
base_looper &	operator= (const base_looper &)
bool	process ()

Static Public Member Functions
static const std::string &	s_class ()

Protected Member Functions
virtual bool	action (const T &a_value)=0
bool	_looper (base_ntu &a_sub, const std::vector< unsigned int > &a_is, unsigned int a_depth, bool &a_stop)

Static Protected Member Functions
static bool	find_is (const base_ntu &a_ntu, const base_col *a_col, std::vector< unsigned int > &a_is, bool &a_found)

Protected Attributes
base_ntu &	m_ntu
const base_col &	m_col

Detailed Description

template<class T>
class tools::aida::base_looper< T >

Definition at line 1129 of file aida_ntuple.

Constructor & Destructor Documentation

base_looper() [1/2]

template<class T >

tools::aida::base_looper< T >::base_looper ( base_ntu &  a_ntu, const base_col &  a_col  )

inline

Definition at line 1138 of file aida_ntuple.

  :m_ntu(a_ntu),m_col(a_col){
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

~base_looper()

template<class T >

virtual tools::aida::base_looper< T >::~base_looper ( )

inlinevirtual

Definition at line 1144 of file aida_ntuple.

                        {
#ifdef TOOLS_MEM
    mem::decrement(s_class().c_str());
#endif
  }

base_looper() [2/2]

template<class T >

tools::aida::base_looper< T >::base_looper ( const base_looper< T > &  a_from )

inline

Definition at line 1150 of file aida_ntuple.

  :m_ntu(a_from.m_ntu),m_col(a_from.m_col){
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

Member Function Documentation

_looper()

template<class T >

bool tools::aida::base_looper< T >::_looper ( base_ntu &  a_sub, const std::vector< unsigned int > &  a_is, unsigned int  a_depth, bool &  a_stop  )

inlineprotected

Definition at line 1227 of file aida_ntuple.

                                    {
    if(a_depth>=a_is.size()) return false;
 
    unsigned int coli = a_is[a_depth];
    const std::vector<base_col*>& cols = a_sub.columns();
    if(coli>=cols.size()) return false;
 
    if(a_depth==(a_is.size()-1)) { //we reach the leaf.
      aida_col<T>* col = safe_cast<base_col, aida_col<T> >(*(cols[coli]));
      if(!col) return false;
      a_sub.start();
      while(a_sub.next()) {
        T v;
        if(!col->get_entry(v)) return false;
        if(!action(v)) {a_stop = true;break;}
      }
    } else {
      aida_col_ntu* col = safe_cast<base_col,aida_col_ntu>(*(cols[coli]));
      if(!col) return false;
      a_sub.start();
      while(a_sub.next()) {
        base_ntu* ntu = col->get_entry(); //not const.
    if(!ntu) return false;
        ntu->start();
        while(ntu->next()) {
          if(!_looper(*ntu,a_is,a_depth+1,a_stop)) return false;
          if(a_stop) break;
        }
      }
    }
    return true;
  }

action()

template<class T >

virtual bool tools::aida::base_looper< T >::action ( const T &  a_value )

protectedpure virtual

Implemented in tools::aida::stat_looper< T >.

find_is()

template<class T >

static bool tools::aida::base_looper< T >::find_is ( const base_ntu &  a_ntu, const base_col *  a_col, std::vector< unsigned int > &  a_is, bool &  a_found  )

inlinestaticprotected

Definition at line 1190 of file aida_ntuple.

                                           {
    // search the indices to reach the sub leaf a_col from the main a_ntu.
    // Note : it is assumed that a_is is empty and a_found = false before
    //        calling with function.
 
    const std::vector<base_col*>& cols = a_ntu.columns();
 
    // look if a_col is a leaf col of a_ntu :
   {unsigned int index = 0;
    tools_vforcit(base_col*,cols,it) {
      if(*it==a_col) {
        a_is.push_back(index); //leaf index is the last one in a_is.
        a_found = true;
        return true;
      }
      index++;
    }}
 
    // go down sub ntu :
   {unsigned int index = 0;
    tools_vforcit(base_col*,cols,it) {
      aida_col_ntu* col = safe_cast<base_col,aida_col_ntu>(*(*it));
      if(col) {
        base_ntu* sub = col->get_to_fill(); //it holds the "sub" cols schema.
        if(!sub) {a_is.clear();return false;}
        a_is.push_back(index);
        if(!find_is(*sub,a_col,a_is,a_found)) {a_is.clear();return false;}
        if(a_found) return true;
        a_is.pop_back();
      }
      index++;
    }}
    return true;
  }

operator=()

template<class T >

base_looper& tools::aida::base_looper< T >::operator= ( const base_looper< T > &  )

inline

Definition at line 1156 of file aida_ntuple.

{return *this;}

process()

template<class T >

bool tools::aida::base_looper< T >::process ( )

inline

Definition at line 1158 of file aida_ntuple.

                 {
    std::vector<unsigned int> is;
    bool found = false;
    if(!find_is(m_ntu,&m_col,is,found)) {
      m_ntu.out() << s_class() << "::process :"
                  << " find_is failed."
                  << std::endl;
      return false;
    }
    if(!found) {
      m_ntu.out() << s_class() << "::process :"
                  << " find_is : col not found."
                  << std::endl;
      return false;
    }
    if(is.empty()) {
      m_ntu.out() << s_class() << "::process :"
                  << " is vec empty."
                  << std::endl;
      return false;
    }
 
    bool stop = false;
    if(!_looper(m_ntu,is,0,stop)) {
      m_ntu.out() << s_class() << "::process :"
                  << " _looper failed."
                  << std::endl;
      return false;
    }
    return true;
  }

s_class()

template<class T >

static const std::string& tools::aida::base_looper< T >::s_class ( )

inlinestatic

Definition at line 1131 of file aida_ntuple.

                                    {
    static const std::string s_v("tools::aida::base_looper<"+stype(T())+">");
    return s_v;
  }

Member Data Documentation

m_col

template<class T >

const base_col& tools::aida::base_looper< T >::m_col

protected

Definition at line 1264 of file aida_ntuple.

m_ntu

template<class T >

base_ntu& tools::aida::base_looper< T >::m_ntu

protected

Definition at line 1263 of file aida_ntuple.

---

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

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/aida_ntuple