/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/rroot/ntuple

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_rroot_ntuple
#define inlib_rroot_ntuple

// to have same API than rcsv::ntuple.

#include "../rntuple"

#include "tree"
#include "leaf"

#include "../cids"
#include "../vfind"
#include "../vmanip"

#ifdef INLIB_MEM
#include "../mem"
#endif

namespace inlib {
namespace rroot {

class ntuple : public virtual read::intuple {
public: //intuple
  virtual void start() {m_index = -1;}
  virtual bool next() { 
    m_index++;
    if((uint64)m_index>=m_tree.entries()) return false;
    return true;
  }
  virtual read::icol* find_icol(const std::string& a_name){
    return find_named<read::icol>(m_cols,a_name);
  }
  virtual const std::vector<read::icol*>& columns() const {return m_cols;}
public:
  template <class T>
  class column : public virtual read::icolumn<T> {
  public: //icol
    virtual const std::string& name() const {return m_leaf.name();}
  public: //icolumn<T>
    virtual bool get_entry(T& a_v) const {
      unsigned int n;
      if(!m_leaf.branch().find_entry(uint32(m_index),n)) {
        a_v = T();
        return false;
      }
      a_v = m_leaf.value();
      return true;
    }
  public:
    column(leaf<T>& a_leaf,int64& a_index)
    :m_leaf(a_leaf)
    ,m_index(a_index) //WARNING : we keep the ref !
    {}
    virtual ~column(){}
  protected:
    column(const column& a_from)
    :read::intuple(a_from),read::icolumn<T>(a_from)
    ,m_leaf(a_from.m_leaf) 
    ,m_index(a_from.m_index)
    {}
    column& operator=(const column&){return *this;}
  protected:
    leaf<T>& m_leaf;
    int64& m_index; //WARNING : a ref.
  };

  class column_string : public virtual read::icol {
  public:
    static cid id_class() {
      static const std::string s_v;
      return _cid(s_v);
    }
  public: //icol
    virtual void* cast(cid a_class) const {
      if(void* p = cmp_cast<column_string>(this,a_class)) {return p;}
      else return 0;
    }
    virtual cid id_cls() const {return id_class();}
    virtual const std::string& name() const {return m_leaf.name();}
  public:
    column_string(leaf_string& a_leaf,int64& a_index)
    :m_leaf(a_leaf)
    ,m_index(a_index) //WARNING : we keep the ref !
    {}
    virtual ~column_string(){}
  protected:
    column_string(const column_string& a_from)
    : read::icol(a_from)
    ,m_leaf(a_from.m_leaf) 
    ,m_index(a_from.m_index)
    {}
    column_string& operator=(const column_string&){return *this;}
  protected:
    leaf_string& m_leaf;
    int64& m_index; //WARNING : a ref.
  };

#ifdef INLIB_MEM
public:
  static const std::string& s_class() {
    static const std::string s_v("inlib::rroot::ntuple");
    return s_v;
  }
#endif
public:
  ntuple(tree& a_tree):m_tree(a_tree),m_index(-1){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  virtual ~ntuple() {
    inlib::clear<read::icol>(m_cols);
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
protected:
  ntuple(const ntuple& a_from)
  :read::intuple(a_from),m_tree(a_from.m_tree){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  ntuple& operator=(const ntuple&){return *this;}
public:
  bool initialize(std::ostream& a_out) {
    inlib::clear<read::icol>(m_cols);

    std::vector<base_leaf*> leaves = m_tree.find_leaves();
   {std::vector<base_leaf*>::const_iterator it;
    for(it=leaves.begin();it!=leaves.end();++it) {
      base_leaf* bl = (*it);
      if(find_named<read::icol>(m_cols,bl->name())) {
        a_out << "inlib::rroot::ntuple::initialize :"
              << " column with name " << sout(bl->name())
              << " already exists."
              << std::endl;
        inlib::clear<read::icol>(m_cols);
        return false;
      }

      if(leaf<float>* lf = cast<base_leaf, leaf<float> >(*bl) ){

        column<float>* col = new column<float>(*lf,m_index);
        m_cols.push_back(col);

      } else if(leaf<double>* ld = cast<base_leaf, leaf<double> >(*bl) ){

        column<double>* col = new column<double>(*ld,m_index);
        m_cols.push_back(col);

      } else if(leaf<int>* li = cast<base_leaf, leaf<int> >(*bl) ){

        column<int>* col = new column<int>(*li,m_index);
        m_cols.push_back(col);

      } else if(leaf_string* ls = cast<base_leaf, leaf_string >(*bl) ){

        column_string* col = new column_string(*ls,m_index);
        m_cols.push_back(col);

      } else {
        a_out << "inlib::rroot::ntuple::initialize :"
              << " column type not yet handled."
              << std::endl;
        inlib::clear<read::icol>(m_cols);
        return false;
      }

    }}

    unsigned int num = m_cols.size();
    if(!num) {
      a_out << "inlib::rroot::ntuple::initialize :"
            << " zero columns."
            << std::endl;
      return false;
    }

    return true;
  }
protected:
  tree& m_tree;
  std::vector<read::icol*> m_cols;
  int64 m_index;
};

}}

#endif