Warning, /include/Geant4/tools/rroot/branch_element is written in an unsupported language. File is not indexed.
0001 // Copyright (C) 2010, Guy Barrand. All rights reserved.
0002 // See the file tools.license for terms.
0003
0004 #ifndef tools_rroot_branch_element
0005 #define tools_rroot_branch_element
0006
0007 #include "branch"
0008 #include "stl_vector"
0009
0010 #include "info"
0011 #include "obj_list"
0012
0013
0014 namespace tools {
0015 namespace rroot {
0016
0017 class branch_element : public branch {
0018 typedef branch parent;
0019 public:
0020 static const std::string& s_class() {
0021 static const std::string s_v("tools::rroot::branch_element");
0022 return s_v;
0023 }
0024 public: //iro
0025 virtual void* cast(const std::string& a_class) const {
0026 if(void* p = cmp_cast<branch_element>(this,a_class)) return p;
0027 return parent::cast(a_class);
0028 }
0029 virtual const std::string& s_cls() const {return s_class();}
0030 public:
0031 static cid id_class() {return branch_element_cid();}
0032 virtual void* cast(cid a_class) const {
0033 if(void* p = cmp_cast<branch_element>(this,a_class)) {return p;}
0034 return parent::cast(a_class);
0035 }
0036 public:
0037 virtual bool stream(buffer& a_buffer) {
0038 _clear();
0039
0040 short v;
0041 unsigned int _s,_c;
0042 if(!a_buffer.read_version(v,_s,_c)) return false;
0043
0044 if(!parent::stream(a_buffer)) {
0045 m_out << "tools::rroot::branch_element::stream : parent::stream() failed." << std::endl;
0046 return false;
0047 }
0048
0049 if(v<=7) {
0050 if(!a_buffer.read(fClassName)) return false;
0051 if(!a_buffer.read(fClassVersion)) return false;
0052 if(!a_buffer.read(fID)) return false;
0053 if(!a_buffer.read(fType)) return false;
0054 if(!a_buffer.read(fStreamerType)) return false;
0055 } else { //v>=8
0056 if(!a_buffer.read(fClassName)) return false;
0057 std::string fParentName;
0058 if(!a_buffer.read(fParentName)) return false;
0059 std::string fCloneName;
0060 if(!a_buffer.read(fCloneName)) return false;
0061 int dummy_int;
0062 if(!a_buffer.read(dummy_int)) return false; //fCheckSum
0063
0064 if(v>=10) {
0065 short dummy_short;
0066 if(!a_buffer.read(dummy_short)) return false; //fClassVersion
0067 } else {
0068 if(!a_buffer.read(dummy_int)) return false; //fClassVersion
0069 }
0070
0071 if(!a_buffer.read(fID)) return false;
0072 if(!a_buffer.read(fType)) return false;
0073 if(!a_buffer.read(fStreamerType)) return false;
0074
0075 if(!a_buffer.read(dummy_int)) return false; //fMaximum
0076
0077 ifac::args args;
0078 if(!pointer_stream(a_buffer,m_fac,args,fBranchCount,fBranchCount_created)) {
0079 m_out << "tools::rroot::branch_element::stream : "
0080 << "can't read fBranchCount."
0081 << std::endl;
0082 return false;
0083 }
0084
0085 if(!pointer_stream(a_buffer,m_fac,args,fBranchCount2,fBranchCount2_created)) {
0086 m_out << "tools::rroot::branch_element::stream : "
0087 << "can't read fBranchCount2."
0088 << std::endl;
0089 _clear();
0090 return false;
0091 }
0092
0093 }
0094
0095 if(!a_buffer.check_byte_count(_s,_c,"TBranchElement")) {_clear();return false;}
0096 return true;
0097 }
0098 public: //branch
0099
0100 virtual bool read_leaves(ifile& a_file,buffer& a_buffer){
0101
0102 // For k<type> value, see the below commented enum EReadWrite from ROOT-6.12.06 code.
0103 static int kInt = 3;
0104 static int kDouble = 8;
0105 static int kDouble32 = 9;
0106 static int kUInt = 13;
0107 static int kBits = 15; // In v4-00-01 version 8, it is Long64_t.
0108 static int kObject = 61;
0109 static int kObjectP = 64;
0110
0111 if(fType==3) { // TClonesArray master branch (has only the number of elements).
0112 //from v4-00-01
0113 int n;
0114 if(!a_buffer.read(n)) return false;
0115
0116 fNdata = n;
0117
0118 return true;
0119
0120 } else if(fType==31) { // TClonesArray sub-branch (contains the elements).
0121 if(fStreamerType==kObject) { //to read EsbRoot fgd_dig.root.
0122 int ndata = fBranchCount->get_ndata();
0123 streamer_info* _info = a_file.find_streamer_info(fClassName);
0124 if(!_info) {
0125 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0126 << " read(kObject) : streamer_infos for ref_cls " << fClassName << " not found."
0127 << std::endl;
0128 return false;
0129 }
0130 streamer_element* _element = _info->find_streamer_element(fID);
0131 if(!_element) {
0132 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0133 << " read(kObject) : for ref_cls " << fClassName << ", fID " << fID << " streamer element not found."
0134 << std::endl;
0135 return false;
0136 }
0137
0138 obj_list* _list = 0;
0139 if(!m_obj) {
0140 _list = new obj_list(m_fac);
0141 m_obj = _list;
0142 } else {
0143 _list = id_cast<iro,obj_list>(*m_obj);
0144 if(!_list) {
0145 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0146 << " read(kObject) : m_obj is not an obj_list."
0147 << std::endl;
0148 return false;
0149 }
0150 }
0151
0152 _list->safe_clear();
0153
0154 for(int index=0;index<ndata;index++) {
0155 ifac::args args;
0156 iro* _obj = m_fac.create(_element->type_name(),args);
0157 if(!_obj) {_list->safe_clear();return false;}
0158 if(!_obj->stream(a_buffer)){
0159 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0160 << " kObject : obj stream of class " << sout(_element->type_name())
0161 << " failed at index " << index << " (" << ndata << ")." << std::endl;
0162 _list->safe_clear();
0163 return false;
0164 }
0165 _list->add_object(_obj); //give ownership.
0166 }
0167
0168 return true;
0169 }
0170 if(fStreamerType==kObjectP) return true;
0171 //from v4-00-01
0172 if(fStreamerType==kDouble32) {
0173 int ndata = fBranchCount->get_ndata();
0174 stl_vector<double>* vec = 0;
0175 if(!m_obj) {
0176 vec = new stl_vector<double>;
0177 m_obj = vec;
0178 } else {
0179 vec = id_cast<iro, stl_vector<double> >(*m_obj);
0180 if(!vec) {
0181 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0182 << " read(kDouble32) : m_obj is not a stl_vector<double>."
0183 << std::endl;
0184 return false;
0185 }
0186 }
0187
0188 vec->resize(ndata);
0189 float afloat;
0190 for(int ii=0;ii<ndata;ii++) {
0191 if(!a_buffer.read(afloat)) {
0192 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0193 << " read(float) failed."
0194 << std::endl;
0195 vec->clear();
0196 return false;
0197 }
0198 (*vec)[ii] = afloat;
0199 }
0200
0201 return true;
0202
0203 } else if(fStreamerType==kDouble) {
0204 int ndata = fBranchCount->get_ndata();
0205 stl_vector<double>* vec = 0;
0206 if(!m_obj) {
0207 vec = new stl_vector<double>;
0208 m_obj = vec;
0209 } else {
0210 vec = id_cast<iro, stl_vector<double> >(*m_obj);
0211 if(!vec) {
0212 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0213 << " read(kDouble) : m_obj is not a stl_vector<double>."
0214 << std::endl;
0215 return false;
0216 }
0217 }
0218
0219 vec->resize(ndata);
0220 double* _value = vec->data();
0221 if(!a_buffer.read_fast_array(_value,ndata)) {
0222 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0223 << " read_fast_array(double) failed."
0224 << std::endl;
0225 vec->clear();
0226 return false;
0227 }
0228
0229 return true;
0230
0231 } else if(fStreamerType==kInt) {
0232 int ndata = fBranchCount->get_ndata();
0233 stl_vector<int>* vec = 0;
0234 if(!m_obj) {
0235 vec = new stl_vector<int>;
0236 m_obj = vec;
0237 } else {
0238 vec = id_cast<iro, stl_vector<int> >(*m_obj);
0239 if(!vec) {
0240 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0241 << " read(kInt) : m_obj is not a stl_vector<int>."
0242 << std::endl;
0243 return false;
0244 }
0245 }
0246
0247 vec->resize(ndata);
0248 int* _value = vec->data();
0249 if(!a_buffer.read_fast_array(_value,ndata)) {
0250 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0251 << " read_fast_array(int) failed."
0252 << std::endl;
0253 vec->clear();
0254 return false;
0255 }
0256
0257 return true;
0258
0259 } else if((fStreamerType==kUInt)||(fStreamerType==kBits)) {
0260 int ndata = fBranchCount->get_ndata();
0261 stl_vector<uint32>* vec = 0;
0262 if(!m_obj) {
0263 vec = new stl_vector<uint32>;
0264 m_obj = vec;
0265 } else {
0266 vec = id_cast<iro, stl_vector<uint32> >(*m_obj);
0267 if(!vec) {
0268 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0269 << " read(kUInt) : m_obj is not a stl_vector<uint32>."
0270 << std::endl;
0271 return false;
0272 }
0273 }
0274
0275 vec->resize(ndata);
0276 uint32* _value = vec->data();
0277 if(!a_buffer.read_fast_array(_value,ndata)) {
0278 m_out << "tools::rroot::branch_element::read_leaves : " << sout(m_name) << " :"
0279 << " read_fast_array(uint) failed."
0280 << std::endl;
0281 vec->clear();
0282 return false;
0283 }
0284
0285 return true;
0286
0287 } else {
0288 m_out << "tools::rroot::branch_element::read_leaves :"
0289 << " name " << m_name << " ref_cls " << fClassName
0290 << " : for type " << fType << ", stream_type " << fStreamerType << " not treated."
0291 << std::endl;
0292 return false;
0293 }
0294
0295 } else if(fType==0) { // to read wroot.root of examples/cpp/wroot.cpp.
0296
0297
0298 if((fID==-1)||
0299 (fID==1) // for pmx to read LHCb files :
0300 ){
0301 if(fBranchCount) {
0302 fNdata = fBranchCount->get_ndata();
0303 } else {
0304 fNdata = 1;
0305 }
0306
0307 // read object :
0308 bool created = false;
0309 if(!m_obj) {
0310 ifac::args args;
0311 m_obj = m_fac.create(fClassName,args);
0312 if(!m_obj) return false;
0313 created = true;
0314 }
0315
0316 if(!m_obj->stream(a_buffer)){
0317 m_out << "tools::rroot::branch_element::read_leaves :"
0318 << " name " << sout(m_name) << ", ref_cls " << sout(fClassName) << " :"
0319 << " obj stream failed."
0320 << std::endl;
0321 if(created) {delete m_obj;m_obj = 0;}
0322 return false;
0323 }
0324
0325 return true;
0326
0327 } else {
0328 m_out << "tools::rroot::branch_element::read_leaves :"
0329 << " name " << m_name << " ref_cls " << fClassName << " :"
0330 << " type 0 with ID " << fID << " not treated."
0331 << std::endl;
0332 return false;
0333 }
0334
0335 }
0336
0337 m_out << "tools::rroot::branch_element::read_leaves :"
0338 << " name " << m_name << " ref_cls " << fClassName
0339 << " : type " << fType << " not treated, stream_type is " << fStreamerType << "."
0340 << std::endl;
0341 return false;
0342 }
0343
0344 virtual bool find_entry(ifile& a_file,uint64 a_entry,uint32& a_nbytes){
0345 //The below line will call the upper read_leaves.
0346 if(!parent::find_entry(a_file,a_entry,a_nbytes)) return false;
0347
0348 if(m_branches.size()) {
0349 tools_vforcit(branch*,m_branches,it) {
0350 uint32 n;
0351 if(!(*it)->find_entry(a_file,a_entry,n)) return false;
0352 a_nbytes += n;
0353 }
0354 }
0355
0356 return true;
0357 }
0358
0359 virtual bool show(std::ostream& a_out,ifile& a_file,uint64 a_entry){
0360 uint32 n;
0361 if(!find_entry(a_file,a_entry,n)) return false;
0362
0363 {std::string _s;
0364 uint32 len = uint32(name().size())+128;
0365 sprintf(_s,len," %-15s = ",name().c_str());
0366 a_out << _s;}
0367
0368 a_out << m_obj << std::endl;
0369
0370 return true;
0371 }
0372 public:
0373 branch_element(std::ostream& a_out,ifac& a_fac)
0374 :parent(a_out,a_fac)
0375 ,m_obj(0)
0376 ,fClassVersion(0)
0377 ,fID(0)
0378 ,fType(0)
0379 ,fStreamerType(-1)
0380 ,fBranchCount(0) //not owner
0381 ,fBranchCount_created(false)
0382 ,fBranchCount2(0) //not owner
0383 ,fBranchCount2_created(false)
0384 ,fNdata(1)
0385 {}
0386
0387 virtual ~branch_element() {
0388 _clear();
0389 if(m_obj) delete m_obj;
0390 }
0391 protected:
0392 branch_element(const branch_element& a_from):iro(a_from),parent(a_from){}
0393 branch_element& operator=(const branch_element&){return *this;}
0394 public:
0395 const std::string& class_name() const {return fClassName;}
0396 int type() const {return fType;}
0397 int streamer_type() const {return fStreamerType;}
0398 int id() const {return fID;}
0399 iro* object() {return m_obj;}
0400 int get_ndata() const {return fNdata;}
0401
0402 template <class T>
0403 stl_vector<T>* object_to_stl_vector() const {
0404 if(!m_obj) {
0405 m_out << "tools::rroot::branch_element::object_to_stl_vector : there is no object." << std::endl;
0406 return 0;
0407 }
0408 stl_vector<T>* od = id_cast<iro, stl_vector<T> >(*m_obj);
0409 if(!od) {
0410 m_out << "tools::rroot::branch_element::object_to_stl_vector :"
0411 << " object of class " << sout(m_obj->s_cls()) << " not a tools::rroot::stl_vector<T>."
0412 << std::endl;
0413 return 0;
0414 }
0415 return od; //WARNING : we are not owner.
0416 }
0417
0418 obj_list* object_to_obj_list() const {
0419 if(!m_obj) {
0420 m_out << "tools::rroot::branch_element::object_to_obj_list : there is no object." << std::endl;
0421 return 0;
0422 }
0423 obj_list* od = id_cast<iro,obj_list>(*m_obj);
0424 if(!od) {
0425 m_out << "tools::rroot::branch_element::object_to_obj_list :"
0426 << " object of class " << sout(m_obj->s_cls()) << " not a tools::rroot::obj_list."
0427 << std::endl;
0428 return 0;
0429 }
0430 return od; //WARNING : we are not owner.
0431 }
0432
0433 template <class T>
0434 stl_vector<T>* find_entry_vec(ifile& a_file,uint64 a_event) {
0435 unsigned int n;
0436 if(!find_entry(a_file,a_event,n)) {
0437 m_out << "tools::rroot::branch_element::find_entry_vec : find_entry() failed." << std::endl;
0438 return 0;
0439 }
0440 if(!m_obj) {
0441 m_out << "tools::rroot::branch_element::find_entry_vec : no object found." << std::endl;
0442 return 0;
0443 }
0444 stl_vector<T>* od = id_cast<iro, stl_vector<T> >(*m_obj);
0445 if(!od) {
0446 m_out << "tools::rroot::branch_element::find_entry_vec :"
0447 << " object not a tools::rroot::stl_vector<T>."
0448 << std::endl;
0449 return 0;
0450 }
0451 return od; //WARNING : we are not owner.
0452 }
0453
0454 protected:
0455 void _clear() {
0456 if(fBranchCount_created) {delete fBranchCount;fBranchCount = 0;fBranchCount_created = false;}
0457 if(fBranchCount2_created) {delete fBranchCount2;fBranchCount2 = 0;fBranchCount2_created = false;}
0458 }
0459 protected:
0460 iro* m_obj;
0461 protected:
0462 std::string fClassName; //Class name of referenced object
0463 int fClassVersion; //Version number of class
0464 int fID; //element serial number in fInfo
0465 int fType; //branch type
0466 int fStreamerType; //branch streamer type
0467 branch_element* fBranchCount; // pointer to primary branchcount branch
0468 bool fBranchCount_created;
0469 branch_element* fBranchCount2; // pointer to secondary branchcount branch
0470 bool fBranchCount2_created;
0471 int fNdata; // Number of data in this branch
0472 };
0473
0474 }}
0475
0476 #endif
0477
