Inheritance diagram for tools::wroot::base_pntuple_column_wise:

[legend]

Collaboration diagram for tools::wroot::base_pntuple_column_wise:

Classes
class	file

Public Member Functions
	base_pntuple_column_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, bool a_verbose)

	base_pntuple_column_wise (std::ostream &a_out, bool a_byte_swap, uint32 a_compression, seek a_seek_directory, const std::vector< uint32 > &a_basket_sizes, const ntuple_booking &a_bkg, bool a_verbose)

virtual	~base_pntuple_column_wise ()

template<class T >
column_ref< T > *	create_column_ref (uint32 a_basket_size, const std::string &a_name, const T &a_ref)

template<class T >
column< T > *	create_column (uint32 a_basket_size, const std::string &a_name, const T &a_def=T())

column_string_ref *	create_column_string_ref (uint32 a_basket_size, const std::string &a_name, const std::string &a_ref)

column_string *	create_column_string (uint32 a_basket_size, const std::string &a_name, const std::string &a_def=std::string())

column_vector_string_ref *	create_column_vector_string_ref (uint32 a_basket_size, const std::string &a_name, const std::vector< std::string > &a_ref, char a_sep)

column_vector_string *	create_column_vector_string (uint32 a_basket_size, 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 (uint32 a_basket_size, const std::string &a_name, const std::vector< T > &a_ref)

template<class T >
std_vector_column< T > *	create_column_vector (uint32 a_basket_size, 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_column_wise (const base_pntuple_column_wise &a_from)

base_pntuple_column_wise &	operator= (const base_pntuple_column_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
file	m_file

std::vector< branch * >	m_branches

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_column_wise.

Constructor & Destructor Documentation

◆ base_pntuple_column_wise() [1/3]

tools::wroot::base_pntuple_column_wise::base_pntuple_column_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,
		bool	a_verbose
	)

inline

Definition at line 53 of file base_pntuple_column_wise.

   :parent(a_out,a_seek_directory,a_name,a_title)
   ,m_file(a_out,a_byte_swap,a_compression,a_verbose)
   {}

◆ base_pntuple_column_wise() [2/3]

tools::wroot::base_pntuple_column_wise::base_pntuple_column_wise	(	std::ostream &	a_out,
		bool	a_byte_swap,
		uint32	a_compression,
		seek	a_seek_directory,
		const std::vector< uint32 > &	a_basket_sizes,
		const ntuple_booking &	a_bkg,
		bool	a_verbose
	)

inline

Definition at line 58 of file base_pntuple_column_wise.

   :parent(a_out,a_seek_directory,a_bkg.name(),a_bkg.title())
   ,m_file(a_out,a_byte_swap,a_compression,a_verbose)
   {
     const std::vector<column_booking>& cols = a_bkg.columns();
  
     if(a_basket_sizes.size()!=cols.size()) {
       a_out << "tools::wroot::base_pntuple_column_wise :"
             << " a_basket_sizes.size() (" << a_basket_sizes.size() << ") != "
             << "a_bkg.columns().size() (" << a_bkg.columns().size() << ")."
             << std::endl;
       return;
     }
     std::vector<uint32>::const_iterator itb = a_basket_sizes.begin();
  
     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>(*itb,(*it).name(),*user)) {\
         a_out << "tools::wroot::base_pntuple_column_wise : create_column_ref(" << (*it).name() << ") failed." << std::endl;\
         safe_clear<icol>(m_cols);\
             safe_clear<branch>(m_branches);\
         return;\
       }\
       itb++;\
         } else {\
           if(!create_column<a__type>(*itb,(*it).name())) {\
         a_out << "tools::wroot::base_pntuple_column_wise : create_column(" << (*it).name() << ") failed." << std::endl;\
         safe_clear<icol>(m_cols);\
             safe_clear<branch>(m_branches);\
         return;\
       }\
       itb++;\
         }\
       }
  
 #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>(*itb,(*it).name(),*vec)) {\
             a_out << "tools::wroot::base_pntuple_column_wise :"\
                   << " create_column failed for std::vector column_ref " << sout((*it).name()) << "."\
                   << std::endl;\
             safe_clear<icol>(m_cols);\
             safe_clear<branch>(m_branches);\
             return;\
           }\
       itb++;\
         } else {\
           if(!create_column_vector<a__type>(*itb,(*it).name())) {\
             a_out << "tools::wroot::base_pntuple_column_wise :"\
                   << " create_column failed for std::vector column " << sout((*it).name()) << "."\
                   << std::endl;\
             safe_clear<icol>(m_cols);\
             safe_clear<branch>(m_branches);\
             return;\
           }\
       itb++;\
         }\
       }
  
            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(*itb,(*it).name(),*user)) {
         a_out << "tools::wroot::base_pntuple_column_wise : create_column_string_ref(" << (*it).name() << ") failed."
               << std::endl;
         safe_clear<icol>(m_cols);
             safe_clear<branch>(m_branches);
         return;
       }
       itb++;
         } else {
           if(!create_column_string(*itb,(*it).name())) {
         a_out << "tools::wroot::base_pntuple_column_wise : create_column_string(" << (*it).name() << ") failed." << std::endl;
         safe_clear<icol>(m_cols);
             safe_clear<branch>(m_branches);
         return;
       }
       itb++;
         }
       }
  
       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(*itb,(*it).name(),*user,sep)) {
         a_out << "tools::wroot::base_pntuple_column_wise :"
                   << " create_column_vector_string_ref(" << (*it).name() << ") failed." << std::endl;
         safe_clear<icol>(m_cols);
             safe_clear<branch>(m_branches);
         return;
       }
       itb++;
         } else {
           if(!create_column_vector_string(*itb,(*it).name(),std::vector<std::string>(),sep)) {
         a_out << "tools::wroot::base_pntuple_column_wise :"
                   << " create_column_vector_string(" << (*it).name() << ") failed." << std::endl;
         safe_clear<icol>(m_cols);
             safe_clear<branch>(m_branches);
         return;
       }
       itb++;
         }
       }
  
       // no leaf_store_class() defined for the other types.
  
       else {
         a_out << "tools::wroot::base_pntuple_column_wise :"
               << " for column " << sout((*it).name())
               << ", type with cid " << (*it).cls_id() << " not yet handled."
               << std::endl;
         //throw
         safe_clear<icol>(m_cols);
         safe_clear<branch>(m_branches);
         return;
       }
  
 #undef TOOLS_WROOT_PNTUPLE_CREATE_COL
 #undef TOOLS_WROOT_PNTUPLE_CREATE_VEC_COL
  
     }
   }

◆ ~base_pntuple_column_wise()

virtual tools::wroot::base_pntuple_column_wise::~base_pntuple_column_wise ( )

inlinevirtual

Definition at line 202 of file base_pntuple_column_wise.

202 {safe_clear<branch>(m_branches);}

◆ base_pntuple_column_wise() [3/3]

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

inlineprotected

Definition at line 204 of file base_pntuple_column_wise.

204 :parent(a_from),m_file(a_from.m_file){}

Member Function Documentation

◆ create_column()

template<class T >

column<T>* tools::wroot::base_pntuple_column_wise::create_column	(	uint32	a_basket_size,
		const std::string &	a_name,
		const T &	a_def = `T()`
	)

inline

Definition at line 221 of file base_pntuple_column_wise.

                                                                                               {
     if(find_named<icol>(m_cols,a_name)) return 0;
     branch*  _branch = new branch(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                   m_seek_directory,a_name,m_name,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     column<T>* col = new column<T>(*_branch,a_name,a_def);
     if(!col) {delete _branch;return 0;}
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ create_column_ref()

template<class T >

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

inline

Definition at line 208 of file base_pntuple_column_wise.

                                                                                                 {
     if(find_named<icol>(m_cols,a_name)) return 0;
     branch* _branch = new branch(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                  m_seek_directory,a_name,m_name,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     column_ref<T>* col = new column_ref<T>(*_branch,a_name,a_ref);
     if(!col) {delete _branch;return 0;}
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ create_column_string()

column_string* tools::wroot::base_pntuple_column_wise::create_column_string	(	uint32	a_basket_size,
		const std::string &	a_name,
		const std::string &	a_def = `std::string()`
	)

inline

Definition at line 245 of file base_pntuple_column_wise.

                                                                             {
     if(find_named<icol>(m_cols,a_name)) return 0;
     branch* _branch = new branch(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                  m_seek_directory,a_name,m_name,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     column_string* col = new column_string(*_branch,a_name,a_def);
     if(!col) {delete _branch;return 0;}
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ create_column_string_ref()

column_string_ref* tools::wroot::base_pntuple_column_wise::create_column_string_ref	(	uint32	a_basket_size,
		const std::string &	a_name,
		const std::string &	a_ref
	)

inline

Definition at line 233 of file base_pntuple_column_wise.

                                                                                                                    {
     if(find_named<icol>(m_cols,a_name)) return 0;
     branch* _branch = new branch(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                  m_seek_directory,a_name,m_name,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     column_string_ref* col = new column_string_ref(*_branch,a_name,a_ref);
     if(!col) {delete _branch;return 0;}
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ create_column_vector()

template<class T >

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

inline

Definition at line 300 of file base_pntuple_column_wise.

                                                                                                                                       {
     if(find_named<icol>(m_cols,a_name)) return 0;
     std_vector_be_pointer<T>* _branch = new std_vector_be_pointer<T>(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                                                      m_seek_directory,a_name,m_name,0,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     std_vector_column<T>* col = new std_vector_column<T>(*_branch,a_name,a_def);
     if(!col) {delete _branch;return 0;}
     _branch->set_pointer(&(col->variable()));
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ create_column_vector_ref()

template<class T >

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

inline

Definition at line 287 of file base_pntuple_column_wise.

                                                                                                                              {
     if(find_named<icol>(m_cols,a_name)) return 0;
     std_vector_be_ref<T>* _branch = new std_vector_be_ref<T>(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                                              m_seek_directory,a_name,m_name,a_ref,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     std_vector_column_ref<T>* col = new std_vector_column_ref<T>(*_branch,a_name,a_ref);
     if(!col) {delete _branch;return 0;}
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ create_column_vector_string()

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

inline

Definition at line 272 of file base_pntuple_column_wise.

                                                                                                   {
     if(find_named<icol>(m_cols,a_name)) return 0;
     branch* _branch = new branch(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                  m_seek_directory,a_name,m_name,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     column_vector_string* col = new column_vector_string(*_branch,a_name,a_def,a_sep);
     if(!col) {delete _branch;return 0;}
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ create_column_vector_string_ref()

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

inline

Definition at line 259 of file base_pntuple_column_wise.

                                                                                                           {
     if(find_named<icol>(m_cols,a_name)) return 0;
     branch* _branch = new branch(m_file.out(),m_file.byte_swap(),m_file.compression(),
                                  m_seek_directory,a_name,m_name,m_file.verbose());
     _branch->set_basket_size(a_basket_size);
     column_vector_string_ref* col = new column_vector_string_ref(*_branch,a_name,a_ref,a_sep);
     if(!col) {delete _branch;return 0;}
     m_branches.push_back(_branch);
     m_cols.push_back(col);
     return col;
   }

◆ operator=()

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

inlineprotected

Definition at line 205 of file base_pntuple_column_wise.

205 {return *this;}

Member Data Documentation

◆ m_branches

std::vector<branch*> tools::wroot::base_pntuple_column_wise::m_branches

protected

Definition at line 314 of file base_pntuple_column_wise.

◆ m_file

file tools::wroot::base_pntuple_column_wise::m_file

protected

Definition at line 313 of file base_pntuple_column_wise.

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

/Users/barrand/private/dev/softinex/g4tools/g4tools/tools/wroot/base_pntuple_column_wise

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ base_pntuple_column_wise() [1/3]

◆ base_pntuple_column_wise() [2/3]

◆ ~base_pntuple_column_wise()

◆ base_pntuple_column_wise() [3/3]

Member Function Documentation

◆ create_column()

◆ create_column_ref()

◆ create_column_string()

◆ create_column_string_ref()

◆ create_column_vector()

◆ create_column_vector_ref()

◆ create_column_vector_string()

◆ create_column_vector_string_ref()

◆ operator=()

Member Data Documentation

◆ m_branches

◆ m_file