tools::wroot::base_pntuple_row_wise Class Reference

Inheritance diagram for tools::wroot::base_pntuple_row_wise:

Collaboration diagram for tools::wroot::base_pntuple_row_wise:

Public Member Functions
	base_pntuple_row_wise (std::ostream &a_out, bool a_byte_swap, uint32 a_compression, seek a_seek_directory, const std::string &a_name, const std::string &a_title, uint32 a_basket_size, bool a_verbose)
	base_pntuple_row_wise (std::ostream &a_out, bool a_byte_swap, uint32 a_compression, seek a_seek_directory, uint32 a_basket_size, const ntuple_booking &a_bkg, bool a_verbose)
virtual	~base_pntuple_row_wise ()
template<class T >
column_ref< T > *	create_column_ref (const std::string &a_name, const T &a_ref)
template<class T >
column< T > *	create_column (const std::string &a_name, const T &a_def=T())
column_string_ref *	create_column_string_ref (const std::string &a_name, const std::string &a_ref)
column_string *	create_column_string (const std::string &a_name, const std::string &a_def=std::string())
column_vector_string_ref *	create_column_vector_string_ref (const std::string &a_name, const std::vector< std::string > &a_ref, char a_sep)
column_vector_string *	create_column_vector_string (const std::string &a_name, const std::vector< std::string > &a_def, char a_sep)
template<class T >
std_vector_column_ref< T > *	create_column_vector_ref (const std::string &a_name, const std::vector< T > &a_ref)
template<class T >
std_vector_column< T > *	create_column_vector (const std::string &a_name, const std::vector< T > &a_def=std::vector< T >())
Public Member Functions inherited from tools::wroot::base_pntuple
	base_pntuple (std::ostream &a_out, seek a_seek_directory, const std::string &a_name, const std::string &a_title)
virtual	~base_pntuple ()
const std::vector< icol * > &	columns () const
template<class T >
column_ref< T > *	find_column_ref (const std::string &a_name)
template<class T >
column< T > *	find_column (const std::string &a_name)
column_string_ref *	find_column_string_ref (const std::string &a_name)
column_string *	find_column_string (const std::string &a_name)
template<class T >
std_vector_column_ref< T > *	find_column_vector_ref (const std::string &a_name)
template<class T >
std_vector_column< T > *	find_column_vector (const std::string &a_name)
column_vector_string_ref *	find_column_vector_string_ref (const std::string &a_name)
column_vector_string *	find_column_vector_string (const std::string &a_name)
void	print_columns (std::ostream &a_out)

Protected Member Functions
	base_pntuple_row_wise (const base_pntuple_row_wise &a_from)
base_pntuple_row_wise &	operator= (const base_pntuple_row_wise &)
Protected Member Functions inherited from tools::wroot::base_pntuple
	base_pntuple (const base_pntuple &a_from)
base_pntuple &	operator= (const base_pntuple &)

Protected Attributes
branch	m_row_wise_branch
Protected Attributes inherited from tools::wroot::base_pntuple
std::ostream &	m_out
seek	m_seek_directory
std::string	m_name
std::string	m_title
std::vector< icol * >	m_cols

Detailed Description

Definition at line 20 of file base_pntuple_row_wise.

Constructor & Destructor Documentation

base_pntuple_row_wise() [1/3]

tools::wroot::base_pntuple_row_wise::base_pntuple_row_wise ( std::ostream &  a_out, bool  a_byte_swap, uint32  a_compression, seek  a_seek_directory, const std::string &  a_name, const std::string &  a_title, uint32  a_basket_size, bool  a_verbose  )

inline

Definition at line 23 of file base_pntuple_row_wise.

  :parent(a_out,a_seek_directory,a_name,a_title)
  ,m_row_wise_branch(a_out,a_byte_swap,a_compression,a_seek_directory,"row_wise_branch","row_wise_branch",a_verbose)
  {
    m_row_wise_branch.set_basket_size(a_basket_size);
  }

base_pntuple_row_wise() [2/3]

tools::wroot::base_pntuple_row_wise::base_pntuple_row_wise ( std::ostream &  a_out, bool  a_byte_swap, uint32  a_compression, seek  a_seek_directory, uint32  a_basket_size, const ntuple_booking &  a_bkg, bool  a_verbose  )

inline

Definition at line 32 of file base_pntuple_row_wise.

  :parent(a_out,a_seek_directory,a_bkg.name(),a_bkg.title())
  ,m_row_wise_branch(a_out,a_byte_swap,a_compression,a_seek_directory,"row_wise_branch","row_wise_branch",a_verbose)
  {
    m_row_wise_branch.set_basket_size(a_basket_size);
 
    const std::vector<column_booking>& cols = a_bkg.columns();
 
    tools_vforcit(column_booking,cols,it){
 
#define TOOLS_WROOT_PNTUPLE_CREATE_COL(a__type) \
      if((*it).cls_id()==_cid(a__type())) {\
        a__type* user = (a__type*)(*it).user_obj();\
        if(user) {\
          if(!create_column_ref<a__type>((*it).name(),*user)) {\
        a_out << "tools::wroot::base_pntuple_row_wise : create_column_ref(" << (*it).name() << ") failed." << std::endl;\
        safe_clear<icol>(m_cols);\
        return;\
      }\
        } else {\
          if(!create_column<a__type>((*it).name())) {\
        a_out << "tools::wroot::base_pntuple_row_wise : create_column(" << (*it).name() << ") failed." << std::endl;\
        safe_clear<icol>(m_cols);\
        return;\
      }\
        }\
      }
 
#define TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL(a__type) \
      if((*it).cls_id()==_cid_std_vector<a__type>()) {\
        std::vector<a__type>* vec = (std::vector<a__type>*)(*it).user_obj();\
        if(vec) {\
          if(!create_column_vector_ref<a__type>((*it).name(),*vec)) {\
            a_out << "tools::wroot::base_pntuple_row_wise :"\
                  << " create_column_vector_ref failed for std::vector column " << sout((*it).name()) << "."\
                  << std::endl;\
            safe_clear<icol>(m_cols);\
            return;\
          }\
        } else {\
          if(!create_column_vector<a__type>((*it).name())) {\
        a_out << "tools::wroot::base_pntuple_row_wise :"\
                  << " create_column_vector failed for std::vector column " << sout((*it).name()) << "."\
              << std::endl;\
        safe_clear<icol>(m_cols);\
        return;\
      }\
        }\
      }
 
           TOOLS_WROOT_PNTUPLE_CREATE_COL(char)
      else TOOLS_WROOT_PNTUPLE_CREATE_COL(short)
      else TOOLS_WROOT_PNTUPLE_CREATE_COL(int)
      else TOOLS_WROOT_PNTUPLE_CREATE_COL(float)
      else TOOLS_WROOT_PNTUPLE_CREATE_COL(double)
 
      else if((*it).cls_id()==_cid(std::string())) {
        std::string* user = (std::string*)(*it).user_obj();
        if(user) {
          if(!create_column_string_ref((*it).name(),*user)) {
        a_out << "tools::wroot::base_pntuple_row_wise : create_column_string_ref(" << (*it).name() << ") failed." << std::endl;
        safe_clear<icol>(m_cols);
        return;
      }
        } else {
          if(!create_column_string((*it).name())) {
        a_out << "tools::wroot::base_pntuple_row_wise : create_column_string(" << (*it).name() << ") failed." << std::endl;
        safe_clear<icol>(m_cols);
        return;
      }
        }
      }
 
      else TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL(char)
      else TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL(short)
      else TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL(int)
      else TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL(float)
      else TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL(double)
 
      else if((*it).cls_id()==_cid_std_vector<std::string>()) {\
        std::vector<std::string>* user = (std::vector<std::string>*)(*it).user_obj();
        char sep = '\n';
        if(user) {
          if(!create_column_vector_string_ref((*it).name(),*user,sep)) {
        a_out << "tools::wroot::base_pntuple_row_wise :"
                  << " create_column_vector_string_ref(" << (*it).name() << ") failed." << std::endl;
        safe_clear<icol>(m_cols);
        return;
      }
        } else {
          if(!create_column_vector_string((*it).name(),std::vector<std::string>(),sep)) {
        a_out << "tools::wroot::base_pntuple_row_wise :"
                  << " create_column_vector_string(" << (*it).name() << ") failed." << std::endl;
        safe_clear<icol>(m_cols);
        return;
      }
        }
      }
 
      // no leaf_store_class() defined for the other types.
 
      else {
        a_out << "tools::wroot::base_pntuple_row_wise :"
              << " for column " << sout((*it).name())
              << ", type with cid " << (*it).cls_id() << " not yet handled."
              << std::endl;
        //throw
        safe_clear<icol>(m_cols);
        return;
      }
 
#undef TOOLS_WROOT_PNTUPLE_CREATE_COL
#undef TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL
    }
  }

~base_pntuple_row_wise()

virtual tools::wroot::base_pntuple_row_wise::~base_pntuple_row_wise ( )

inlinevirtual

Definition at line 150 of file base_pntuple_row_wise.

{}

base_pntuple_row_wise() [3/3]

tools::wroot::base_pntuple_row_wise::base_pntuple_row_wise ( const base_pntuple_row_wise &  a_from )

inlineprotected

Definition at line 152 of file base_pntuple_row_wise.

  :parent(a_from)
  ,m_row_wise_branch(m_out,false,0,0,"row_wise_branch","row_wise_branch",false)
  {}

Member Function Documentation

create_column()

template<class T >

column<T>* tools::wroot::base_pntuple_row_wise::create_column ( const std::string &  a_name, const T &  a_def = T()  )

inline

Definition at line 168 of file base_pntuple_row_wise.

                                                                         {
    if(find_named<icol>(m_cols,a_name)) return 0;
    column<T>* col = new column<T>(m_row_wise_branch,a_name,a_def);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

create_column_ref()

template<class T >

column_ref<T>* tools::wroot::base_pntuple_row_wise::create_column_ref ( const std::string &  a_name, const T &  a_ref  )

inline

Definition at line 159 of file base_pntuple_row_wise.

                                                                           {
    if(find_named<icol>(m_cols,a_name)) return 0;
    column_ref<T>* col = new column_ref<T>(m_row_wise_branch,a_name,a_ref);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

create_column_string()

column_string* tools::wroot::base_pntuple_row_wise::create_column_string ( const std::string &  a_name, const std::string &  a_def = std::string()  )

inline

Definition at line 184 of file base_pntuple_row_wise.

                                                                                                    {
    if(find_named<icol>(m_cols,a_name)) return 0;
    column_string* col = new column_string(m_row_wise_branch,a_name,a_def);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

create_column_string_ref()

column_string_ref* tools::wroot::base_pntuple_row_wise::create_column_string_ref ( const std::string &  a_name, const std::string &  a_ref  )

inline

Definition at line 176 of file base_pntuple_row_wise.

                                                                                              {
    if(find_named<icol>(m_cols,a_name)) return 0;
    column_string_ref* col = new column_string_ref(m_row_wise_branch,a_name,a_ref);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

create_column_vector()

template<class T >

std_vector_column<T>* tools::wroot::base_pntuple_row_wise::create_column_vector ( const std::string &  a_name, const std::vector< T > &  a_def = std::vector<T>()  )

inline

Definition at line 219 of file base_pntuple_row_wise.

                                                                                                                 {
    if(find_named<icol>(m_cols,a_name)) return 0;
    std_vector_column<T>* col = new std_vector_column<T>(m_row_wise_branch,a_name,a_def);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

create_column_vector_ref()

template<class T >

std_vector_column_ref<T>* tools::wroot::base_pntuple_row_wise::create_column_vector_ref ( const std::string &  a_name, const std::vector< T > &  a_ref  )

inline

Definition at line 210 of file base_pntuple_row_wise.

                                                                                                        {
    if(find_named<icol>(m_cols,a_name)) return 0;
    std_vector_column_ref<T>* col = new std_vector_column_ref<T>(m_row_wise_branch,a_name,a_ref);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

create_column_vector_string()

column_vector_string* tools::wroot::base_pntuple_row_wise::create_column_vector_string ( const std::string &  a_name, const std::vector< std::string > &  a_def, char  a_sep  )

inline

Definition at line 201 of file base_pntuple_row_wise.

                                                                                                                          {
    if(find_named<icol>(m_cols,a_name)) return 0;
    column_vector_string* col = new column_vector_string(m_row_wise_branch,a_name,a_def,a_sep);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

create_column_vector_string_ref()

column_vector_string_ref* tools::wroot::base_pntuple_row_wise::create_column_vector_string_ref ( const std::string &  a_name, const std::vector< std::string > &  a_ref, char  a_sep  )

inline

Definition at line 192 of file base_pntuple_row_wise.

                                                                                                          {
    if(find_named<icol>(m_cols,a_name)) return 0;
    column_vector_string_ref* col = new column_vector_string_ref(m_row_wise_branch,a_name,a_ref,a_sep);
    if(!col) return 0;
    m_cols.push_back(col);
    return col;
  }

operator=()

base_pntuple_row_wise& tools::wroot::base_pntuple_row_wise::operator= ( const base_pntuple_row_wise &  )

inlineprotected

Definition at line 156 of file base_pntuple_row_wise.

{return *this;}

Member Data Documentation

m_row_wise_branch

branch tools::wroot::base_pntuple_row_wise::m_row_wise_branch

protected

Definition at line 228 of file base_pntuple_row_wise.

---

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

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/wroot/base_pntuple_row_wise