tools::wroot::tree Class Reference

Inheritance diagram for tools::wroot::tree:

Collaboration diagram for tools::wroot::tree:

Public Member Functions
virtual const std::string &	name () const
virtual const std::string &	title () const
virtual const std::string &	store_class_name () const
virtual bool	stream (buffer &a_buffer) const
virtual idir &	dir ()
virtual const idir &	dir () const
	tree (idir &a_dir, const std::string &a_name, const std::string &a_title, bool a_managed=true)
virtual	~tree ()
std::ostream &	out () const
const std::vector< branch * > &	branches () const
uint64	entries () const
branch *	create_branch (const std::string &a_name)
template<class TYPE >
leaf_ref< TYPE > *	create_leaf_ref (const std::string &a_name, const TYPE &a_ref)
	ref : ////////////////////////////////////// More...
leaf_string_ref *	create_leaf_string_ref (const std::string &a_name, const std::string &a_ref)
template<class T >
leaf_element *	create_std_vector_leaf_ref (const std::string &a_name, const std::vector< T > &a_ref)
template<class T >
std_vector_be_ref< T > *	create_std_vector_be_ref (const std::string &a_name, const std::vector< T > &a_ref)
template<class T >
std_vector_be< T > *	create_std_vector_be (const std::string &a_name, const std::vector< T > &a_def=std::vector< T >())
template<class T >
std_vector_be_pointer< T > *	create_std_vector_be_pointer (const std::string &a_name, std::vector< T > *a_pointer)
template<class TYPE >
leaf< TYPE > *	create_leaf (const std::string &a_name)
leaf_object *	create_leaf (const std::string &a_name, const iobject &a_obj)
bool	fill (uint32 &a_nbytes)
void	reset ()
Public Member Functions inherited from tools::wroot::iobject
virtual	~iobject ()
Public Member Functions inherited from tools::wroot::itree
virtual	~itree ()

Protected Member Functions
	tree (const tree &a_from)
tree &	operator= (const tree &)

Protected Attributes
idir &	m_dir
std::ostream &	m_out
std::string	m_name
std::string	m_title
obj_array< branch >	m_branches
uint64	m_entries
uint64	m_tot_bytes
uint64	m_zip_bytes

Detailed Description

Definition at line 17 of file tree.

Constructor & Destructor Documentation

tree() [1/2]

tools::wroot::tree::tree ( idir &  a_dir, const std::string &  a_name, const std::string &  a_title, bool  a_managed = true  )

inline

Definition at line 86 of file tree.

  :m_dir(a_dir)
  ,m_out(a_dir.file().out())
  ,m_name(a_name)
  ,m_title(a_title)
  ,m_entries(0)
  ,m_tot_bytes(0)
  ,m_zip_bytes(0)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    if(a_managed) a_dir.append_object(this); //a_dir takes ownership of tree.
  }

~tree()

virtual tools::wroot::tree::~tree ( )

inlinevirtual

Definition at line 100 of file tree.

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

tree() [2/2]

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

inlineprotected

Definition at line 106 of file tree.

  :iobject(a_from),itree(a_from)
  ,m_dir(a_from.m_dir)
  ,m_out(a_from.m_out)
  {}

Member Function Documentation

branches()

const std::vector<branch*>& tools::wroot::tree::branches ( ) const

inline

Definition at line 114 of file tree.

{return m_branches;}

create_branch()

branch* tools::wroot::tree::create_branch ( const std::string &  a_name )

inline

Definition at line 119 of file tree.

                                                {
    const ifile& _file = m_dir.file();
    branch* br = new branch(m_out,_file.byte_swap(),_file.compression(),
                            m_dir.seek_directory(),a_name,m_name,_file.verbose());
    if(!br) return 0;
    m_branches.push_back(br);
    return br;
  }

create_leaf() [1/2]

template<class TYPE >

leaf<TYPE>* tools::wroot::tree::create_leaf ( const std::string &  a_name )

inline

Definition at line 184 of file tree.

                                                  {
    branch* br = create_branch(a_name);
    if(!br) return 0;
    return br->create_leaf<TYPE>(a_name);
  }

create_leaf() [2/2]

leaf_object* tools::wroot::tree::create_leaf ( const std::string &  a_name, const iobject &  a_obj  )

inline

Definition at line 190 of file tree.

                                                                        {
    const ifile& _file = m_dir.file();
    branch_object* br = new branch_object(m_out,_file.byte_swap(),_file.compression(),
                                          m_dir.seek_directory(),a_name,m_name,_file.verbose());
    m_branches.push_back(br);
    return br->create_leaf(a_name,a_obj);
  }

create_leaf_ref()

template<class TYPE >

leaf_ref<TYPE>* tools::wroot::tree::create_leaf_ref ( const std::string &  a_name, const TYPE &  a_ref  )

inline

ref : //////////////////////////////////////

Definition at line 132 of file tree.

                                                                            {
    branch* br = create_branch(a_name);
    if(!br) return 0;
    return br->create_leaf_ref<TYPE>(a_name,a_ref);
  }

create_leaf_string_ref()

leaf_string_ref* tools::wroot::tree::create_leaf_string_ref ( const std::string &  a_name, const std::string &  a_ref  )

inline

Definition at line 138 of file tree.

                                                                                         {
    branch* br = create_branch(a_name);
    if(!br) return 0;
    return br->create_leaf_string_ref(a_name,a_ref);
  }

create_std_vector_be()

template<class T >

std_vector_be<T>* tools::wroot::tree::create_std_vector_be ( const std::string &  a_name, const std::vector< T > &  a_def = std::vector<T>()  )

inline

Definition at line 166 of file tree.

                                                                                                            {
    const ifile& _file = m_dir.file();
    std_vector_be<T>* br = new std_vector_be<T>(m_out,_file.byte_swap(),_file.compression(),
                                                m_dir.seek_directory(),a_name,m_name,a_def,_file.verbose());
    m_branches.push_back(br);
    return br;
  }

create_std_vector_be_pointer()

template<class T >

std_vector_be_pointer<T>* tools::wroot::tree::create_std_vector_be_pointer ( const std::string &  a_name, std::vector< T > *  a_pointer  )

inline

Definition at line 175 of file tree.

                                                                                                         {
    const ifile& _file = m_dir.file();
    std_vector_be_pointer<T>* br = new std_vector_be_pointer<T>(m_out,_file.byte_swap(),_file.compression(),
                                                                m_dir.seek_directory(),a_name,m_name,a_pointer,_file.verbose());
    m_branches.push_back(br);
    return br;
  }

create_std_vector_be_ref()

template<class T >

std_vector_be_ref<T>* tools::wroot::tree::create_std_vector_be_ref ( const std::string &  a_name, const std::vector< T > &  a_ref  )

inline

Definition at line 157 of file tree.

                                                                                                   {
    const ifile& _file = m_dir.file();
    std_vector_be_ref<T>* br = new std_vector_be_ref<T>(m_out,_file.byte_swap(),_file.compression(),
                                                        m_dir.seek_directory(),a_name,m_name,a_ref,_file.verbose());
    m_branches.push_back(br);
    return br;
  }

create_std_vector_leaf_ref()

template<class T >

leaf_element* tools::wroot::tree::create_std_vector_leaf_ref ( const std::string &  a_name, const std::vector< T > &  a_ref  )

inline

Definition at line 145 of file tree.

                                                                                             {
    const ifile& _file = m_dir.file();
    std_vector_be_ref<T>* br = new std_vector_be_ref<T>(m_out,_file.byte_swap(),_file.compression(),
                                                        m_dir.seek_directory(),a_name,m_name,a_ref,_file.verbose());
    leaf_element* le = br->create_leaf_element(a_name);
    m_branches.push_back(br);
    return le;
  }

dir() [1/2]

virtual idir& tools::wroot::tree::dir ( )

inlinevirtual

Implements tools::wroot::itree.

Definition at line 83 of file tree.

{return m_dir;}

dir() [2/2]

virtual const idir& tools::wroot::tree::dir ( ) const

inlinevirtual

Implements tools::wroot::itree.

Definition at line 84 of file tree.

{return m_dir;}

entries()

uint64 tools::wroot::tree::entries ( ) const

inline

Definition at line 117 of file tree.

{return m_entries;}

fill()

bool tools::wroot::tree::fill ( uint32 &  a_nbytes )

inline

Definition at line 198 of file tree.

                              {
    // Fill all branches of a Tree :
    //   This function loops on all the branches of this tree.
    //   For each branch, it copies to the branch buffer (basket) the current
    //   values of the leaves data types.
    //   If a leaf is a simple data type, a simple conversion to a machine
    //   independent format has to be done.
    a_nbytes = 0;
    tools_vforcit(branch*,m_branches,it) {
      //FIXME if ((*it)->testBit(kDoNotProcess)) continue;
      uint32 n,add_bytes,nout;
      if(!(*it)->fill(m_dir.file(),n,add_bytes,nout)) {a_nbytes = 0;return false;}
      a_nbytes += n;
      m_tot_bytes += add_bytes;
      m_zip_bytes += nout;
    }
 
    m_entries++;
 
    //if (fTotBytes - fSavedBytes > fAutoSave) {
    //  if(!autoSave()) return false;
    //}
 
    return true;
  }

name()

virtual const std::string& tools::wroot::tree::name ( ) const

inlinevirtual

Implements tools::wroot::iobject.

Definition at line 25 of file tree.

{return m_name;}

operator=()

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

inlineprotected

Definition at line 111 of file tree.

{return *this;}

out()

std::ostream& tools::wroot::tree::out ( ) const

inline

Definition at line 113 of file tree.

{return m_out;}

reset()

void tools::wroot::tree::reset ( )

inline

Definition at line 224 of file tree.

               {
    // Reset buffers and entries count in all branches/leaves
    m_entries       = 0;
    m_tot_bytes     = 0;
    m_zip_bytes     = 0;
  //fSavedBytes     = 0;
  //fTotalBuffers   = 0;
  //fChainOffset    = 0;
   {tools_vforcit(branch*,m_branches,it) (*it)->reset();}
  }

store_class_name()

virtual const std::string& tools::wroot::tree::store_class_name ( ) const

inlinevirtual

Implements tools::wroot::iobject.

Definition at line 27 of file tree.

                                                    {
    static const std::string s_v("TTree");
    return s_v;
  }

stream()

virtual bool tools::wroot::tree::stream ( buffer &  a_buffer ) const

inlinevirtual

Implements tools::wroot::iobject.

Definition at line 31 of file tree.

                                              {
    unsigned int c;
    if(!a_buffer.write_version(5,c)) return false;
 
    if(!Named_stream(a_buffer,m_name,m_title)) return false;
 
    // Beurk.
    if(!AttLine_stream(a_buffer)) return false;
    if(!AttFill_stream(a_buffer)) return false;
    if(!AttMarker_stream(a_buffer)) return false;
 
    double fEntries = (double)m_entries;
    if(!a_buffer.write(fEntries)) return false;
 
    double fTotBytes = (double)m_tot_bytes;
    double fZipBytes = (double)m_zip_bytes;
    if(!a_buffer.write(fTotBytes)) return false;
    if(!a_buffer.write(fZipBytes)) return false;
    if(!a_buffer.write((double)0)) return false; //fSavedBytes
    if(!a_buffer.write((int)0)) return false;    //fTimerInterval
    if(!a_buffer.write((int)25)) return false;   //fScanField (25)
    if(!a_buffer.write((int)0)) return false;    //fUpdate
    if(!a_buffer.write((int)1000000000)) return false; //fMaxEntryLoop
    int fMaxVirtualSize = 0;
    int fAutoSave = 100000000;
    if(!a_buffer.write(fMaxVirtualSize)) return false;
    if(!a_buffer.write(fAutoSave)) return false;
    if(!a_buffer.write((int)1000000)) return false;    //fEstimate;
 
    if(!m_branches.stream(a_buffer)) return false;
 
   {obj_array<base_leaf> m_leaves;
    tools_vforcit(branch*,m_branches,itb) {
      const std::vector<base_leaf*>& leaves = (*itb)->leaves();
      tools_vforcit(base_leaf*,leaves,itl) {
        m_leaves.push_back(*itl); //WARNING : ownership touchy.
      }
    }
    if(!m_leaves.stream(a_buffer)) return false;
    m_leaves.clear();} //WARNING : important.
 
    // fIndexValues (TArrayD).
    if(!a_buffer.write_array(std::vector<double>())) return false; //TArrayD
    // fIndex (TArrayI).
    if(!a_buffer.write_array(std::vector<int>())) return false; //TArrayI
 
    if(!a_buffer.set_byte_count(c)) return false;
    return true;
  }

title()

virtual const std::string& tools::wroot::tree::title ( ) const

inlinevirtual

Implements tools::wroot::iobject.

Definition at line 26 of file tree.

{return m_title;}

Member Data Documentation

m_branches

obj_array<branch> tools::wroot::tree::m_branches

protected

Definition at line 241 of file tree.

m_dir

idir& tools::wroot::tree::m_dir

protected

Definition at line 235 of file tree.

m_entries

uint64 tools::wroot::tree::m_entries

protected

Definition at line 242 of file tree.

m_name

std::string tools::wroot::tree::m_name

protected

Definition at line 238 of file tree.

m_out

std::ostream& tools::wroot::tree::m_out

protected

Definition at line 236 of file tree.

m_title

std::string tools::wroot::tree::m_title

protected

Definition at line 239 of file tree.

m_tot_bytes

uint64 tools::wroot::tree::m_tot_bytes

protected

Definition at line 243 of file tree.

m_zip_bytes

uint64 tools::wroot::tree::m_zip_bytes

protected

Definition at line 244 of file tree.

---

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

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