// Copyright (C) 2010, Guy Barrand. All rights reserved. // See the file tools.license for terms. #ifndef tools_wroot_branch #define tools_wroot_branch #include "leaf" #include "basket" #include "itree" #include "idir" #include "../forit" namespace tools { namespace wroot { class branch : public virtual ibo { static uint32 START_BIG_FILE() {return 2000000000;} //static uint32 kDoNotProcess() {return (1<<10);} // Active bit for branches #ifdef TOOLS_MEM static const std::string& s_class() { static const std::string s_v("tools::wroot::branch"); return s_v; } #endif public: //ibo virtual const std::string& store_cls() const { static const std::string s_v("TBranch"); return s_v; } virtual bool stream(buffer& a_buffer) const { unsigned int c; if(!a_buffer.write_version(8,c)) return false; if(!Named_stream(a_buffer,m_name,m_title)) return false; if(!AttFill_stream(a_buffer)) return false; int fCompress = m_tree.dir().file().compression(); int fEntryOffsetLen = 1000; int fOffset = 0; int fSplitLevel = 0; if(!a_buffer.write(fCompress)) return false; if(!a_buffer.write(m_basket_size)) return false; if(!a_buffer.write(fEntryOffsetLen)) return false; if(!a_buffer.write(m_write_basket)) return false; int fEntryNumber = (int)m_entry_number; if(!a_buffer.write(fEntryNumber)) return false; if(!a_buffer.write(fOffset)) return false; if(!a_buffer.write(m_max_baskets)) return false; if(!a_buffer.write(fSplitLevel)) 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(!m_branches.stream(a_buffer)) return false; if(!m_leaves.stream(a_buffer)) return false; if(!m_baskets.stream(a_buffer)) return false; // See TStreamerInfo::ReadBuffer::WriteBasicPointer if(!a_buffer.write((char)1)) return false; if(!a_buffer.write_fast_array(fBasketBytes,m_max_baskets)) return false; if(!a_buffer.write((char)1)) return false; if(!a_buffer.write_fast_array(fBasketEntry,m_max_baskets)) return false; char isBigFile = 1; //GB : begin //if(fTree.directory().file().end()>RIO_START_BIG_FILE()) isBigFile = 2; {for(uint32 i=0;iSTART_BIG_FILE()) { isBigFile = 2; break; } }} //GB : end if(!a_buffer.write(isBigFile)) return false; if(isBigFile==2) { if(!a_buffer.write_fast_array(fBasketSeek,m_max_baskets)) return false; } else { for(uint32 i=0;iSTART_BIG_FILE()) { //G.Barrand : add this test. m_out << "tools::wroot::branch::stream :" << " attempt to write big Seek " << fBasketSeek[i] << " on 32 bits." << std::endl; return false; } if(!a_buffer.write((seek32)fBasketSeek[i])) return false; } } // fFileName if(!a_buffer.write(std::string(""))) return false; if(!a_buffer.set_byte_count(c)) return false; return true; } public: branch(itree& a_tree, const std::string& a_name, const std::string& a_title) :m_tree(a_tree) ,m_out(a_tree.dir().file().out()) ,m_name(a_name) ,m_title(a_title) ,fAutoDelete(false) //,m_branches(true) //,m_leaves(true) ,m_basket_size(32000) ,m_write_basket(0) ,m_entry_number(0) ,m_entries(0) ,m_tot_bytes(0) ,m_zip_bytes(0) ,m_max_baskets(10) ,fBasketBytes(0) ,fBasketEntry(0) ,fBasketSeek(0) { #ifdef TOOLS_MEM mem::increment(s_class().c_str()); #endif fBasketBytes = new uint32[m_max_baskets]; fBasketEntry = new uint32[m_max_baskets]; fBasketSeek = new seek[m_max_baskets]; {for(uint32 i=0;i leaf* create_leaf(const std::string& a_name, const std::string& a_title){ leaf* lf = new leaf(m_out,*this,a_name,a_title); m_leaves.push_back(lf); return lf; } const std::vector& leaves() const {return m_leaves;} bool fill(uint32& a_nbytes) { a_nbytes = 0; //FIXME if (TestBit(kDoNotProcess)) return 0; basket* bk = m_baskets[m_write_basket]; if(!bk) { m_out << "tools::wroot::branch::fill :" << " get_basket failed." << std::endl; return false; } buffer& buf = bk->datbuf(); uint32 lold = buf.length(); bk->update(bk->key_length()+lold); m_entries++; m_entry_number++; if(!fill_leaves(buf)) return false; uint32 lnew = buf.length(); uint32 nbytes = lnew - lold; uint32 nsize = 0; // Should we create a new basket? // Compare expected next size with m_basket_size. if((lnew+2*nsize+nbytes)>=m_basket_size) { uint32 nout; if(!bk->write_on_file(m_write_basket,nout)) { m_out << "tools::wroot::branch::fill :" << " basket.write_buffer() failed." << std::endl; return false; } fBasketBytes[m_write_basket] = bk->number_of_bytes(); //fBasketEntry[m_write_basket] //can't be set here. fBasketSeek[m_write_basket] = bk->seek_key(); uint32 add_bytes = bk->object_size() + bk->key_length(); delete bk; m_baskets[m_write_basket] = 0; m_tot_bytes += add_bytes; m_zip_bytes += nout; m_tree.add_tot_bytes(add_bytes); m_tree.add_zip_bytes(nout); bk = new basket(m_tree.dir().file(),m_tree.dir().seek_directory(), m_name,m_title,"TBasket",m_basket_size); m_write_basket++; if(m_write_basket>=m_baskets.size()) { m_baskets.resize(2*m_write_basket,0); } m_baskets[m_write_basket] = bk; if(m_write_basket>=m_max_baskets) { //Increase BasketEntry buffer of a minimum of 10 locations // and a maximum of 50 per cent of current size uint32 newsize = mx(10,uint32(1.5*m_max_baskets)); if(newsize>=START_BIG_FILE()) { //we are going to have pb with uint32[] indexing. m_out << "tools::wroot::branch::fill :" << " new size for fBasket[Bytes,Entry,Seek] arrays" << " is too close of 32 bits limit." << std::endl; m_out << "tools::wroot::branch::fill :" << " you have to work with larger basket size." << std::endl; return false; } if(!realloc(fBasketBytes,newsize,m_max_baskets,true)) { m_out << "tools::wroot::branch::fill : realloc failed." << std::endl; return false; } if(!realloc(fBasketEntry,newsize,m_max_baskets,true)){ m_out << "tools::wroot::branch::fill : realloc failed." << std::endl; return false; } if(!realloc(fBasketSeek,newsize,m_max_baskets,true)){ m_out << "tools::wroot::branch::fill : realloc failed." << std::endl; return false; } m_max_baskets = newsize; } fBasketBytes[m_write_basket] = 0; fBasketEntry[m_write_basket] = (uint32)m_entry_number; fBasketSeek[m_write_basket] = 0; } a_nbytes = nbytes; return true; } protected: bool fill_leaves(buffer& a_buffer) { tools_vforit(base_leaf*,m_leaves,it) { if(!(*it)->fill_basket(a_buffer)) return false; } return true; } protected: itree& m_tree; std::ostream& m_out; ObjArray m_baskets; protected: //Object //uint32 m_bits; //Named std::string m_name; std::string m_title; bool fAutoDelete; ObjArray m_branches; ObjArray m_leaves; uint32 m_basket_size; // Initial Size of Basket Buffer uint32 m_write_basket; // Last basket number written uint64 m_entry_number; // Current entry number (last one filled in this branch) uint64 m_entries; // Number of entries uint64 m_tot_bytes; uint64 m_zip_bytes; uint32 m_max_baskets; uint32* fBasketBytes; //[m_max_baskets] Lenght of baskets on file uint32* fBasketEntry; //[m_max_baskets] Table of first entry in eack basket seek* fBasketSeek; //[m_max_baskets] Addresses of baskets on file }; }} #endif