Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 2 // See the file tools.license for terms. 3 4 #ifndef tools_wroot_tree 5 #define tools_wroot_tree 6 7 #include "itree" 8 #include "iobject" 9 #include "idir" 10 11 #include "branch_element" 12 #include "branch_object" 13 14 namespace tools { 15 namespace wroot { 16 17 class tree : public virtual iobject, public vi 18 #ifdef TOOLS_MEM 19 static const std::string& s_class() { 20 static const std::string s_v("tools::wroot 21 return s_v; 22 } 23 #endif 24 public: //iobject 25 virtual const std::string& name() const {ret 26 virtual const std::string& title() const {re 27 virtual const std::string& store_class_name( 28 static const std::string s_v("TTree"); 29 return s_v; 30 } 31 virtual bool stream(buffer& a_buffer) const 32 unsigned int c; 33 if(!a_buffer.write_version(5,c)) return fa 34 35 if(!Named_stream(a_buffer,m_name,m_title)) 36 37 // Beurk. 38 if(!AttLine_stream(a_buffer)) return false 39 if(!AttFill_stream(a_buffer)) return false 40 if(!AttMarker_stream(a_buffer)) return fal 41 42 double fEntries = (double)m_entries; 43 if(!a_buffer.write(fEntries)) return false 44 45 double fTotBytes = (double)m_tot_bytes; 46 double fZipBytes = (double)m_zip_bytes; 47 if(!a_buffer.write(fTotBytes)) return fals 48 if(!a_buffer.write(fZipBytes)) return fals 49 if(!a_buffer.write((double)0)) return fals 50 if(!a_buffer.write((int)0)) return false; 51 if(!a_buffer.write((int)25)) return false; 52 if(!a_buffer.write((int)0)) return false; 53 if(!a_buffer.write((int)1000000000)) retur 54 int fMaxVirtualSize = 0; 55 int fAutoSave = 100000000; 56 if(!a_buffer.write(fMaxVirtualSize)) retur 57 if(!a_buffer.write(fAutoSave)) return fals 58 if(!a_buffer.write((int)1000000)) return f 59 60 if(!m_branches.stream(a_buffer)) return fa 61 62 {obj_array<base_leaf> m_leaves; 63 tools_vforcit(branch*,m_branches,itb) { 64 const std::vector<base_leaf*>& leaves = 65 tools_vforcit(base_leaf*,leaves,itl) { 66 m_leaves.push_back(*itl); //WARNING : 67 } 68 } 69 if(!m_leaves.stream(a_buffer)) return fals 70 m_leaves.clear();} //WARNING : important. 71 72 // fIndexValues (TArrayD). 73 if(!a_buffer.write_array(std::vector<doubl 74 // fIndex (TArrayI). 75 if(!a_buffer.write_array(std::vector<int>( 76 77 if(!a_buffer.set_byte_count(c)) return fal 78 return true; 79 } 80 public: //itree 81 //virtual void add_tot_bytes(uint32 a_n) {m_ 82 //virtual void add_zip_bytes(uint32 a_n) {m_ 83 virtual idir& dir() {return m_dir;} 84 virtual const idir& dir() const {return m_di 85 public: 86 tree(idir& a_dir,const std::string& a_name,c 87 :m_dir(a_dir) 88 ,m_out(a_dir.file().out()) 89 ,m_name(a_name) 90 ,m_title(a_title) 91 ,m_entries(0) 92 ,m_tot_bytes(0) 93 ,m_zip_bytes(0) 94 { 95 #ifdef TOOLS_MEM 96 mem::increment(s_class().c_str()); 97 #endif 98 if(a_managed) a_dir.append_object(this); / 99 } 100 virtual ~tree(){ 101 #ifdef TOOLS_MEM 102 mem::decrement(s_class().c_str()); 103 #endif 104 } 105 protected: 106 tree(const tree& a_from) 107 :iobject(a_from),itree(a_from) 108 ,m_dir(a_from.m_dir) 109 ,m_out(a_from.m_out) 110 {} 111 tree& operator=(const tree&){return *this;} 112 public: 113 std::ostream& out() const {return m_out;} 114 const std::vector<branch*>& branches() const 115 //uint64 tot_bytes() const {return m_tot_byt 116 //uint64 zip_bytes() const {return m_zip_byt 117 uint64 entries() const {return m_entries;} 118 119 branch* create_branch(const std::string& a_n 120 const ifile& _file = m_dir.file(); 121 branch* br = new branch(m_out,_file.byte_s 122 m_dir.seek_directo 123 if(!br) return 0; 124 m_branches.push_back(br); 125 return br; 126 } 127 128 //////////////////////////////////////////// 129 /// ref : ////////////////////////////////// 130 //////////////////////////////////////////// 131 template <class TYPE> 132 leaf_ref<TYPE>* create_leaf_ref(const std::s 133 branch* br = create_branch(a_name); 134 if(!br) return 0; 135 return br->create_leaf_ref<TYPE>(a_name,a_ 136 } 137 138 leaf_string_ref* create_leaf_string_ref(cons 139 branch* br = create_branch(a_name); 140 if(!br) return 0; 141 return br->create_leaf_string_ref(a_name,a 142 } 143 144 template <class T> 145 leaf_element* create_std_vector_leaf_ref(con 146 const ifile& _file = m_dir.file(); 147 std_vector_be_ref<T>* br = new std_vector_ 148 149 leaf_element* le = br->create_leaf_element 150 m_branches.push_back(br); 151 return le; 152 } 153 //////////////////////////////////////////// 154 //////////////////////////////////////////// 155 //////////////////////////////////////////// 156 template <class T> 157 std_vector_be_ref<T>* create_std_vector_be_r 158 const ifile& _file = m_dir.file(); 159 std_vector_be_ref<T>* br = new std_vector_ 160 161 m_branches.push_back(br); 162 return br; 163 } 164 165 template <class T> 166 std_vector_be<T>* create_std_vector_be(const 167 const ifile& _file = m_dir.file(); 168 std_vector_be<T>* br = new std_vector_be<T 169 170 m_branches.push_back(br); 171 return br; 172 } 173 174 template <class T> 175 std_vector_be_pointer<T>* create_std_vector_ 176 const ifile& _file = m_dir.file(); 177 std_vector_be_pointer<T>* br = new std_vec 178 179 m_branches.push_back(br); 180 return br; 181 } 182 183 template <class TYPE> 184 leaf<TYPE>* create_leaf(const std::string& a 185 branch* br = create_branch(a_name); 186 if(!br) return 0; 187 return br->create_leaf<TYPE>(a_name); 188 } 189 190 leaf_object* create_leaf(const std::string& 191 const ifile& _file = m_dir.file(); 192 branch_object* br = new branch_object(m_ou 193 m_di 194 m_branches.push_back(br); 195 return br->create_leaf(a_name,a_obj); 196 } 197 198 bool fill(uint32& a_nbytes) { 199 // Fill all branches of a Tree : 200 // This function loops on all the branch 201 // For each branch, it copies to the bra 202 // values of the leaves data types. 203 // If a leaf is a simple data type, a si 204 // independent format has to be done. 205 a_nbytes = 0; 206 tools_vforcit(branch*,m_branches,it) { 207 //FIXME if ((*it)->testBit(kDoNotProcess 208 uint32 n,add_bytes,nout; 209 if(!(*it)->fill(m_dir.file(),n,add_bytes 210 a_nbytes += n; 211 m_tot_bytes += add_bytes; 212 m_zip_bytes += nout; 213 } 214 215 m_entries++; 216 217 //if (fTotBytes - fSavedBytes > fAutoSave) 218 // if(!autoSave()) return false; 219 //} 220 221 return true; 222 } 223 224 void reset() { 225 // Reset buffers and entries count in all 226 m_entries = 0; 227 m_tot_bytes = 0; 228 m_zip_bytes = 0; 229 //fSavedBytes = 0; 230 //fTotalBuffers = 0; 231 //fChainOffset = 0; 232 {tools_vforcit(branch*,m_branches,it) (*it) 233 } 234 protected: 235 idir& m_dir; 236 std::ostream& m_out; 237 //Named 238 std::string m_name; 239 std::string m_title; 240 241 obj_array<branch> m_branches; 242 uint64 m_entries; // Number of entries 243 uint64 m_tot_bytes; // Total number of bytes 244 uint64 m_zip_bytes; // Total number of bytes 245 }; 246 247 }} 248 249 #endif