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

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_rall
#define inlib_rroot_rall

#include "streamers"
#include "fac"
#include "tree"

namespace inlib {
namespace rroot {

inline bool read_key(std::ostream& a_out,
                     inlib::rroot::key& a_key,
                     bool a_dump){
  unsigned int sz;    
  char* buf = a_key.get_object_buffer(sz); //we don't have ownership of buf.
  if(!buf) {
    a_out << "inlib::rroot::read_key :"
          << " can't get data buffer of " << a_key.object_name() << "."
          << std::endl;
    return false;
  }

  //a_out << "inlib::rroot::read_key :"
  //      << " get data buffer size " << sz << "."
  //      << std::endl;

  inlib::rroot::buffer b(a_out,a_key.file().byte_swap(),
                         sz,buf,a_key.key_length(),false);

  if(a_key.object_class()==inlib::rroot::TH1F_cls()) {
    inlib::histo::h1d* h = inlib::rroot::TH1F_stream(b);
    if(!h) {
      a_out << "inlib::rroot::read_key :"
            << " TH1F streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==inlib::rroot::TH1D_cls()) {
    inlib::histo::h1d* h = inlib::rroot::TH1D_stream(b);
    if(!h) {
      a_out << "inlib::rroot::read_key :"
            << " TH1D streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==inlib::rroot::TH2F_cls()) {
    inlib::histo::h2d* h = inlib::rroot::TH2F_stream(b);
    if(!h) {
      a_out << "inlib::rroot::read_key :"
            << " TH2F streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==inlib::rroot::TH2D_cls()) {
    inlib::histo::h2d* h = 
        inlib::rroot::TH2D_stream(b); //we get ownership of h.
    if(!h) {
      a_out << "inlib::rroot::read_key :"
            << " TH2D streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==inlib::rroot::TProfile_cls()) {
    inlib::histo::p1d* p = inlib::rroot::TProfile_stream(b);
    if(!p) {
      a_out << "inlib::rroot::read_key :"
            << " TProfile streaming failed"
            << std::endl;
    } else {
      if(a_dump) p->hprint(a_out);
    }
    delete p;

  } else if(a_key.object_class()==TTree_cls()) {
   
    inlib::rroot::fac fac(a_key.file());
    inlib::rroot::tree tree(a_key.file(),fac);
    if(!tree.stream(b)) {
      a_out << "inlib::rroot::read_key :"
            << " TTree streaming failed"
            << std::endl;
    } else {
      //tree->dump(a_out);
      if(a_dump) {
        tree.dump(a_out,"","  ");

        uint32 entries = tree.entries();  

       /*
       {for(uint32 j=0;j<10;j++){ //to test memory.
        for(uint32 i=0;i<entries;i++){
          uint32 n;
          if(!tree.find_entry(i,n)) {
            a_out << " can't find entry " << i
                  << std::endl;
          }       
        }
        }}
        */
  
        for(uint32 i=0;i<5;i++){
          if(!tree.show(a_out,i)) {
            a_out << " show failed for entry " << i
                  << std::endl;
          }       
        }
        for(uint32 i=mx<uint32>(5,entries-5);i<entries;i++){
          if(!tree.show(a_out,i)) {
            a_out << " show failed for entry " << i
                  << std::endl;
          }
        }
 
      }
    }
        
  } else if(a_key.object_class()==inlib::rroot::TDirectory::store_class()) {

    //we should not pass here.

  } else {
    a_out << "inlib::rroot::read_key :"
          << " dont't know how to read key with object class "
          << inlib::sout(a_key.object_class())
          << std::endl;
  }
  return true;
}

inline void read(std::ostream& a_out,
                 inlib::rroot::ifile& a_file,
                 const std::vector<inlib::rroot::key*>& a_keys,
                 bool a_recursive,
                 bool a_ls,
                 bool a_dump,
                 unsigned int a_spaces) {

 {std::vector<inlib::rroot::key*>::const_iterator it;
  for(it=a_keys.begin();it!=a_keys.end();++it) {
    inlib::rroot::key& k = *(*it);
    if(k.object_class()!=inlib::rroot::TDirectory::store_class()) {
      if(a_ls||a_dump) {
        {for(unsigned index=0;index<a_spaces;index++) a_out << " ";}
        std::string label = k.object_name();
        a_out << "object : " << sout(label)
              << ", class : " << k.object_class()
              << std::endl;
        //k.dump(a_out);
      }
      if(!read_key(a_out,k,a_dump)) return;
    }
  }}

 {std::vector<inlib::rroot::key*>::const_iterator it;
  for(it=a_keys.begin();it!=a_keys.end();++it) {
    inlib::rroot::key& k = *(*it);
    if(k.object_class()==inlib::rroot::TDirectory::store_class()) {

      if(a_ls||a_dump) {
        {for(unsigned index=0;index<a_spaces;index++) a_out << " ";}
        std::string label = k.object_name();
        a_out << "directory : " << label << std::endl;
      }

      if(!a_recursive) continue;

      inlib::uint32 sz;    
      char* buf = k.get_object_buffer(sz); 
      if(!buf) {
        a_out  << "read :"
               << " can't get directory data buffer."
               << std::endl;
      } else {
        inlib::rroot::buffer b(a_out,a_file.byte_swap(),
                               sz,buf,k.key_length(),false);
        inlib::rroot::TDirectory dir(a_file);
        if(!dir.stream(b)) {
          a_out << "read :"
                << " can't stream TDirectory."
                << std::endl;
        } else {
          const std::vector<inlib::rroot::key*>& keys = dir.keys();
          read(a_out,a_file,keys,a_recursive,a_ls,a_dump,a_spaces+1);
        }
      }
    }
  }}
}

}}

#endif