Jpp
JMultipleFileScanner.hh
Go to the documentation of this file.
1 #ifndef __JSUPPORT__JMULTIPLEFILESCANNER__
2 #define __JSUPPORT__JMULTIPLEFILESCANNER__
3 
4 #include <string>
5 #include <vector>
6 #include <limits>
7 
8 #include "TChain.h"
9 #include "TChainElement.h"
10 
11 #include "JLang/JObjectIterator.hh"
12 #include "JLang/JTypeList.hh"
13 #include "JLang/JNullType.hh"
14 #include "JLang/JMultiEquals.hh"
15 #include "JLang/JException.hh"
16 
17 #include "JSupport/JLimit.hh"
18 #include "JSupport/JFileScanner.hh"
19 
20 
21 /**
22  * \file
23  * Scanning of objects from multiple files according a format that follows from the extension of each file name.
24  * \author mdejong
25  */
26 namespace JSUPPORT {}
27 namespace JPP { using namespace JSUPPORT; }
28 
29 namespace JSUPPORT {
30 
32  using JLANG::JPointer;
33  using JLANG::JTypeList;
34  using JLANG::JTYPELIST;
35  using JLANG::JNullType;
36  using JLANG::JMultiEquals;
37  using JLANG::skip_type;
38  using JLANG::JException;
39 
40 
41  /**
42  * Auxiliary base class for list of file names.
43  */
45  public std::vector<std::string>
46  {
47  /**
48  * Default constructor.
49  */
51  {}
52 
53 
54  /**
55  * Constructor.
56  *
57  * \param file_name file name
58  */
59  JMultipleFileScanner_t(const std::string& file_name) :
60  std::vector<std::string>(1, file_name)
61  {}
62 
63 
64  /**
65  * Constructor.
66  *
67  * \param chain ROOT chain
68  */
69  JMultipleFileScanner_t(const TChain& chain)
70  {
71  setFilelist(chain);
72  }
73 
74 
75  /**
76  * Get file list.
77  *
78  * \return list of file names
79  */
81  {
82  return static_cast<const JMultipleFileScanner_t&>(*this);
83  }
84 
85 
86  /**
87  * Get file list.
88  *
89  * \return list of file names
90  */
92  {
93  return static_cast<JMultipleFileScanner_t&>(*this);
94  }
95 
96 
97  /**
98  * Set file list.
99  *
100  * \param file_list list of file names
101  */
102  void setFilelist(const JMultipleFileScanner_t& file_list)
103  {
104  static_cast<JMultipleFileScanner_t&>(*this) = file_list;
105  }
106 
107 
108  /**
109  * Set file list.
110  *
111  * \param chain ROOT chain
112  */
113  void setFilelist(const TChain& chain)
114  {
115  this->clear();
116 
117  const TObjArray* array = chain.GetListOfFiles();
118 
119  for (Int_t i = 0; i != array->GetEntries(); ++i) {
120 
121  const TChainElement* p = (const TChainElement*) array->At(i);
122 
123  this->push_back(p->GetTitle());
124  }
125  }
126 
127 
128  /**
129  * Read file list from input.
130  *
131  * \param in input stream
132  * \param object file list
133  * \return input stream
134  */
135  friend inline std::istream& operator>>(std::istream& in, JMultipleFileScanner_t& object)
136  {
137  for (std::string buffer; in >> buffer; ) {
138  object.push_back(buffer.c_str());
139  }
140 
141  return in;
142  }
143 
144 
145  /**
146  * Write file list to output.
147  *
148  * \param out output stream
149  * \param object file list
150  * \return output stream
151  */
152  friend inline std::ostream& operator<<(std::ostream& out, const JMultipleFileScanner_t& object)
153  {
154  for (const_iterator i = object.begin(); i != object.end(); ++i) {
155  out << *i << std::endl;
156  }
157 
158  return out;
159  }
160  };
161 
162 
163  /**
164  * General purpose class for object reading from a list of file names.
165  */
166  template<class T = JNullType>
168 
169 
170  /**
171  * Template specialisation of JMultipleFileScanner for undefined type.\n
172  * This specialisation is used as a virtual base class for all implementations of JMultipleFileScanner for defined type(s).\n
173  * The method JMultipleFileScanner::configure should be used to set the internal parameters.
174  *
175  * This class is a simple container for a list of file names and has an additional counter limit by extending from JSUPPORT::JLimit.\n
176  * This counter limit will be used to limit the number of calls to the method <tt>next</tt> of the derived class.\n
177  * Note that the counter limit can only be set via the member or friend methods of class JSUPPORT::JLimit.
178  */
179  template<>
181  public JMultipleFileScanner_t,
182  public JLimit,
183  public JMultiEquals<JMultipleFileScanner<JNullType>,
184  JTYPELIST<JLimit, JMultipleFileScanner_t>::typelist>
185  {
186  public:
187 
189 
190  /**
191  * Default constructor.
192  */
194  {}
195 
196 
197  /**
198  * Virtual destructor.
199  */
201  {}
202 
203 
204  /**
205  * Configure.
206  *
207  * \param input list of file names
208  * \param limit limit
209  */
210  void configure(const input_type& input, const JLimit& limit)
211  {
212  this->setFilelist(input);
213  this->setLimit (limit);
214  }
215 
216 
217  /**
218  * Read multiple file scanner from input.
219  *
220  * Note that only file names are read.
221  *
222  * \param in input stream
223  * \param object multiple file scanner
224  * \return input stream
225  */
226  friend inline std::istream& operator>>(std::istream& in, JMultipleFileScanner& object)
227  {
228  return in >> object.getFilelist();
229  }
230 
231 
232  /**
233  * Write multiple file scanner to output.
234  *
235  * Note that only file names are written.
236  *
237  * \param out output stream
238  * \param object multiple file scanner
239  * \return output stream
240  */
241  friend inline std::ostream& operator<<(std::ostream& out, const JMultipleFileScanner& object)
242  {
243  return out << object.getFilelist();
244  }
245  };
246 
247 
248  /**
249  * Implementation of object reading for single data type from a list of file names.
250  *
251  * This class extends the JMultipleFileScanner<JNullType> class and
252  * implements the JLANG::JRewindableObjectIterator interface.\n
253  * When the method hasNext() is called,
254  * the next file in the list is opened when the previous file is exhausted.
255  */
256  template<class T>
257  class JMultipleFileScanner :
258  public virtual JMultipleFileScanner<>,
259  public JRewindableObjectIterator<T>
260  {
261  public:
262 
265 
266  /**
267  * Default constructor.
268  */
270  index (0),
271  counter(0)
272  {}
273 
274 
275  /**
276  * Copy constructor.
277  *
278  * Note that the counter limit is not copied and the index and counter are set to zero.
279  *
280  * \param input input
281  */
282  template<class JTypelist_t>
284  index (0),
285  counter(0)
286  {
287  this->configure(input.getFilelist(), JLimit());
288  }
289 
290 
291  /**
292  * Constructor.
293  *
294  * \param file_list list of file names
295  * \param limit limit
296  */
297  JMultipleFileScanner(const input_type& file_list, const JLimit& limit = JLimit()) :
298  index (0),
299  counter(0)
300  {
301  configure(file_list, limit);
302  }
303 
304 
305  /**
306  * Get current file name.
307  *
308  * Note that this method should only be called when method hasNext() returns true.
309  *
310  * \return file name
311  */
312  const std::string& getFilename() const
313  {
314  return this->at(index);
315  }
316 
317 
318  /**
319  * Get counter.
320  *
321  * \return counter
322  */
324  {
325  return counter;
326  }
327 
328 
329  /**
330  * Rewind.
331  */
332  virtual void rewind()
333  {
334  if (scanner.is_open()) {
335  scanner.close();
336  }
337 
338  index = 0;
339  counter = 0;
340 
341  scanner.reset();
342  }
343 
344 
345  /**
346  * Check availability of next element.
347  *
348  * \return true if the iteration has more elements; else false
349  */
350  virtual bool hasNext()
351  {
352  if (is_valid()) {
353 
354  if (counter < getUpperLimit() && index != this->size()) {
355 
356  // first time around
357 
358  if (!scanner.is_open()) {
359  scanner.open(getFilename().c_str());
360  }
361 
362  if (counter < getLowerLimit()) {
363  counter += scanner.skip(getLowerLimit() - counter);
364  }
365 
366  if (!scanner.hasNext()) {
367 
368  scanner.close();
369 
370  ++index;
371 
372  return hasNext();
373  }
374 
375  return true;
376 
377  } else {
378 
379  // last time around
380 
381  if (scanner.is_open()) {
382  scanner.close();
383  }
384 
385  scanner.reset();
386  }
387  }
388 
389  return false;
390  }
391 
392 
393  /**
394  * Get next element.
395  *
396  * \return pointer to element
397  */
398  virtual const pointer_type& next()
399  {
400  ++counter;
401 
402  return scanner.next();
403  }
404 
405 
406  /**
407  * Skip items.
408  *
409  * \param ns number of items to skip
410  * \return number of items skipped
411  */
412  virtual skip_type skip(const skip_type ns)
413  {
414  skip_type i = 0;
415 
416  while (this->hasNext() && i != ns) {
417  i += scanner.skip(ns - i);
418  }
419 
420  counter += i;
421 
422  return i;
423  }
424 
425 
426  protected:
428  unsigned int index;
430  };
431 
432 
433  /**
434  * Implementation of object reading for multiple data types from a list of file names.
435  *
436  * This class recursively implements the JLANG::JRewindableObjectIterator interface
437  * for all data types by deriving from:
438  * - JMultipleFileScanner<JHead_t>; and
439  * - JMultipleFileScanner<JTail_t>.
440  *
441  * The method rewind(), rewinds each object iterator.
442  */
443  template<class JHead_t, class JTail_t>
444  class JMultipleFileScanner< JTypeList<JHead_t, JTail_t> > :
445  public virtual JMultipleFileScanner<>,
446  public JRewindableObjectIterator< JTypeList<JHead_t, JTail_t> >,
447  public JMultipleFileScanner<JHead_t>,
448  public JMultipleFileScanner<JTail_t>
449  {
450  public:
451 
453 
456 
457 
458  /**
459  * Default constructor.
460  */
463  {}
464 
465 
466  /**
467  * Copy constructor.
468  *
469  * Note that the counter limit is not copied and the index and counter are set to zero.
470  *
471  * \param input input
472  */
473  template<class JTypelist_t>
475  {
476  this->configure(input.getFilelist(), JLimit());
477  }
478 
479 
480  /**
481  * Constructor.
482  *
483  * \param file_list list of file names
484  * \param limit limit
485  */
486  JMultipleFileScanner(const input_type& file_list, const JLimit& limit = JLimit())
487  {
488  this->configure(file_list, limit);
489  }
490 
491 
492  /**
493  * Rewind.\n
494  * This method rewinds the JMultipleFileScanner for each data type.
495  */
496  virtual void rewind()
497  {
500  }
501 
502 
503  /**
504  * Skip items.
505  *
506  * \param ns number of items to skip
507  * \return number of items skipped
508  */
509  virtual skip_type skip(const skip_type ns)
510  {
511  if (JMultipleFileScanner<JHead_t>::skip(ns) == ns &&
513  return ns;
514  else
515  throw JException("JMultipleFileScanner::skip(): inconsistent number of items skipped.");
516  }
517  };
518 
519 
520  /**
521  * Terminator class of recursive JMultipleFileScanner class.
522  */
523  template<class JHead_t>
525  public JMultipleFileScanner<JHead_t>
526  {
527  public:
528 
530 
531  /**
532  * Default constructor.
533  */
535  JMultipleFileScanner<JHead_t>()
536  {}
537 
538 
539  /**
540  * Copy constructor.
541  *
542  * Note that the counter limit is not copied and the index and counter are set to zero.
543  *
544  * \param input input
545  */
546  template<class JTypelist_t>
548  {
549  this->configure(input.getFilelist(), JLimit());
550  }
551 
552 
553  /**
554  * Constructor.
555  *
556  * \param file_list list of file names
557  * \param limit limit
558  */
559  JMultipleFileScanner(const input_type& file_list, const JLimit& limit = JLimit())
560  {
561  this->configure(file_list, limit);
562  }
563  };
564 }
565 
566 #endif
JException.hh
JSUPPORT::JMultipleFileScanner< JNullType >::operator>>
friend std::istream & operator>>(std::istream &in, JMultipleFileScanner &object)
Read multiple file scanner from input.
Definition: JMultipleFileScanner.hh:226
JLANG::skip_type
unsigned int skip_type
Type definition for number of objects to skip.
Definition: JObjectIterator.hh:25
JSUPPORT::JFileScanner
Object reading from file.
Definition: JFileScanner.hh:34
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JNullType > >::JMultipleFileScanner
JMultipleFileScanner()
Default constructor.
Definition: JMultipleFileScanner.hh:534
JSUPPORT::JLimit
Auxiliary class for defining the range of iterations of objects.
Definition: JLimit.hh:41
JSUPPORT::JMultipleFileScanner_t
Auxiliary base class for list of file names.
Definition: JMultipleFileScanner.hh:44
JSUPPORT::JMultipleFileScanner::counter
counter_type counter
Definition: JMultipleFileScanner.hh:429
JSUPPORT::JMultipleFileScanner_t::getFilelist
JMultipleFileScanner_t & getFilelist()
Get file list.
Definition: JMultipleFileScanner.hh:91
JSUPPORT::JMultipleFileScanner_t::operator>>
friend std::istream & operator>>(std::istream &in, JMultipleFileScanner_t &object)
Read file list from input.
Definition: JMultipleFileScanner.hh:135
JSUPPORT::JMultipleFileScanner::pointer_type
JRewindableObjectIterator< T >::pointer_type pointer_type
Definition: JMultipleFileScanner.hh:264
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JTail_t > >::JMultipleFileScanner
JMultipleFileScanner(const JMultipleFileScanner< JTypelist_t > &input)
Copy constructor.
Definition: JMultipleFileScanner.hh:474
JSUPPORT::JMultipleFileScanner_t::operator<<
friend std::ostream & operator<<(std::ostream &out, const JMultipleFileScanner_t &object)
Write file list to output.
Definition: JMultipleFileScanner.hh:152
JAANET::is_valid
bool is_valid(const T &value)
Check validity of given value.
Definition: JHead.hh:823
JSUPPORT::JMultipleFileScanner::getFilename
const std::string & getFilename() const
Get current file name.
Definition: JMultipleFileScanner.hh:312
JLimit.hh
JObjectIterator.hh
JSUPPORT::JMultipleFileScanner::JMultipleFileScanner
JMultipleFileScanner(const input_type &file_list, const JLimit &limit=JLimit())
Constructor.
Definition: JMultipleFileScanner.hh:297
JLANG::JNullType
Auxiliary class for no type definition.
Definition: JNullType.hh:19
std::vector
Definition: JSTDTypes.hh:12
JLANG::JTYPELIST
Auxiliary class for recursive type list generation.
Definition: JTypeList.hh:377
JSUPPORT::JMultipleFileScanner_t::setFilelist
void setFilelist(const JMultipleFileScanner_t &file_list)
Set file list.
Definition: JMultipleFileScanner.hh:102
JSUPPORT::JMultipleFileScanner::index
unsigned int index
Definition: JMultipleFileScanner.hh:428
JSUPPORT::JMultipleFileScanner_t::JMultipleFileScanner_t
JMultipleFileScanner_t(const TChain &chain)
Constructor.
Definition: JMultipleFileScanner.hh:69
JPP
This name space includes all other name spaces (except KM3NETDAQ, KM3NET and ANTARES).
Definition: JAAnetToolkit.hh:37
JLANG::JPointer
Template implementation of class that holds pointer to object(s).
Definition: JPointer.hh:22
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JTail_t > >::JMultipleFileScanner
JMultipleFileScanner()
Default constructor.
Definition: JMultipleFileScanner.hh:461
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JTail_t > >::rewind
virtual void rewind()
Rewind.
Definition: JMultipleFileScanner.hh:496
JSUPPORT::JMultipleFileScanner::getCounter
counter_type getCounter() const
Get counter.
Definition: JMultipleFileScanner.hh:323
JSUPPORT::JMultipleFileScanner_t::setFilelist
void setFilelist(const TChain &chain)
Set file list.
Definition: JMultipleFileScanner.hh:113
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JNullType > >::input_type
JMultipleFileScanner ::input_type input_type
Definition: JMultipleFileScanner.hh:529
JSUPPORT::JMultipleFileScanner::next
virtual const pointer_type & next()
Get next element.
Definition: JMultipleFileScanner.hh:398
JMultiEquals.hh
JSUPPORT::JMultipleFileScanner_t::JMultipleFileScanner_t
JMultipleFileScanner_t(const std::string &file_name)
Constructor.
Definition: JMultipleFileScanner.hh:59
JLANG::JTypeList
Type list.
Definition: JTypeList.hh:22
JSUPPORT::JMultipleFileScanner::hasNext
virtual bool hasNext()
Check availability of next element.
Definition: JMultipleFileScanner.hh:350
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JNullType > >::JMultipleFileScanner
JMultipleFileScanner(const input_type &file_list, const JLimit &limit=JLimit())
Constructor.
Definition: JMultipleFileScanner.hh:559
JSUPPORT::JMultipleFileScanner_t::getFilelist
const JMultipleFileScanner_t & getFilelist() const
Get file list.
Definition: JMultipleFileScanner.hh:80
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JNullType > >::JMultipleFileScanner
JMultipleFileScanner(const JMultipleFileScanner< JTypelist_t > &input)
Copy constructor.
Definition: JMultipleFileScanner.hh:547
JSUPPORT::JMultipleFileScanner_t::JMultipleFileScanner_t
JMultipleFileScanner_t()
Default constructor.
Definition: JMultipleFileScanner.hh:50
JLANG::JRewindableObjectIterator
Interface for object iteration with rewinding.
Definition: JObjectIterator.hh:362
JLANG::JMultiEquals
Template definition of auxiliary base class for composite data structures composed of base classes wi...
Definition: JMultiEquals.hh:31
JSUPPORT::JMultipleFileScanner::JMultipleFileScanner
JMultipleFileScanner()
Default constructor.
Definition: JMultipleFileScanner.hh:269
JSUPPORT::JMultipleFileScanner::rewind
virtual void rewind()
Rewind.
Definition: JMultipleFileScanner.hh:332
JSUPPORT::JMultipleFileScanner< JNullType >::operator<<
friend std::ostream & operator<<(std::ostream &out, const JMultipleFileScanner &object)
Write multiple file scanner to output.
Definition: JMultipleFileScanner.hh:241
JSUPPORT::JMultipleFileScanner< JNullType >::configure
void configure(const input_type &input, const JLimit &limit)
Configure.
Definition: JMultipleFileScanner.hh:210
JSUPPORT::JMultipleFileScanner
General purpose class for object reading from a list of file names.
Definition: JMultipleFileScanner.hh:167
JSUPPORT::JMultipleFileScanner::input_type
JMultipleFileScanner ::input_type input_type
Definition: JMultipleFileScanner.hh:263
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JTail_t > >::skip
virtual skip_type skip(const skip_type ns)
Skip items.
Definition: JMultipleFileScanner.hh:509
std
Definition: jaanetDictionary.h:36
JSUPPORT
Support classes and methods for experiment specific I/O.
Definition: JDataWriter.cc:38
JTypeList.hh
JNullType.hh
JSUPPORT::JMultipleFileScanner< JNullType >::~JMultipleFileScanner
virtual ~JMultipleFileScanner()
Virtual destructor.
Definition: JMultipleFileScanner.hh:200
JFileScanner.hh
JSUPPORT::JMultipleFileScanner< JNullType >::JMultipleFileScanner
JMultipleFileScanner()
Default constructor.
Definition: JMultipleFileScanner.hh:193
JSUPPORT::JMultipleFileScanner< JNullType >::input_type
JMultipleFileScanner_t input_type
Definition: JMultipleFileScanner.hh:188
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JTail_t > >::input_type
JMultipleFileScanner ::input_type input_type
Definition: JMultipleFileScanner.hh:452
JROOT::counter_type
Long64_t counter_type
Type definition for counter.
Definition: JCounter.hh:24
JSUPPORT::JMultipleFileScanner::JMultipleFileScanner
JMultipleFileScanner(const JMultipleFileScanner< JTypelist_t > &input)
Copy constructor.
Definition: JMultipleFileScanner.hh:283
JTOOLS::configure
void configure(const T &value, const JAbstractCollection< JAbscissa_t > &bounds, JBool< false > option)
Configuration of value.
Definition: JToolsToolkit.hh:285
JLANG::JException
General exception.
Definition: JException.hh:40
JSUPPORT::JMultipleFileScanner< JTypeList< JHead_t, JTail_t > >::JMultipleFileScanner
JMultipleFileScanner(const input_type &file_list, const JLimit &limit=JLimit())
Constructor.
Definition: JMultipleFileScanner.hh:486
JSUPPORT::JMultipleFileScanner::skip
virtual skip_type skip(const skip_type ns)
Skip items.
Definition: JMultipleFileScanner.hh:412
JSUPPORT::JMultipleFileScanner::scanner
JFileScanner< T > scanner
Definition: JMultipleFileScanner.hh:427