InputRecordWalker.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef FRAMEWORK_INPUTRECORDWALKER_H
#define FRAMEWORK_INPUTRECORDWALKER_H
 
 
#include "Framework/InputRecord.h"
 
namespace o2::framework
{
 
class InputRecordWalker
{
 public:
  InputRecordWalker() = delete;
  InputRecordWalker(InputRecord& record, std::vector<InputSpec> filterSpecs = {}) : mRecord(record), mFilterSpecs(filterSpecs) {}
 
  template <typename T>
  class Iterator
  {
   public:
    using self_type = Iterator;
    using iterator_category = std::forward_iterator_tag;
    using value_type = T;
    using reference = T&;
    using pointer = T*;
    using difference_type = std::ptrdiff_t;
    // the iterator over the input routes
    using input_iterator = decltype(std::declval<InputRecord>().begin());
 
    Iterator() = delete;
 
    Iterator(InputRecord& parent, input_iterator it, input_iterator end, std::vector<InputSpec> const& filterSpecs)
      : mParent(parent), mInputIterator(it), mEnd(end), mCurrent(mInputIterator.begin()), mFilterSpecs(filterSpecs)
    {
      next(true);
    }
 
    ~Iterator() = default;
 
    // prefix increment
    self_type& operator++()
    {
      next();
      return *this;
    }
    // postfix increment
    self_type operator++(int /*unused*/)
    {
      self_type copy(*this);
      operator++();
      return copy;
    }
    // return reference
    reference operator*()
    {
      return *mCurrent;
    }
    // comparison
    bool operator==(const self_type& other) const
    {
      bool result = mInputIterator == other.mInputIterator;
      result = result && mCurrent == other.mCurrent;
      return result;
    }
 
    bool operator!=(const self_type& rh) const
    {
      return not operator==(rh);
    }
 
   private:
    // the iterator over the parts in one channel
    using part_iterator = typename input_iterator::const_iterator;
 
    bool next(bool isInitialPart = false)
    {
      while (mInputIterator != mEnd) {
        while (mCurrent != mInputIterator.end()) {
          // increment on the level of one input
          if (!isInitialPart && (mCurrent == mInputIterator.end() || ++mCurrent == mInputIterator.end())) {
            // no more parts, go to next input
            break;
          }
          isInitialPart = false;
          // check filter rules
          if (mFilterSpecs.size() > 0) {
            bool isSelected = false;
            for (auto const& spec : mFilterSpecs) {
              if ((isSelected = DataRefUtils::match(*mCurrent, spec)) == true) {
                break;
              }
            }
            if (!isSelected) {
              continue;
            }
          }
          return true;
        }
        ++mInputIterator;
        mCurrent = mInputIterator.begin();
        isInitialPart = true;
      } // end loop over record
      return false;
    }
 
    InputRecord& mParent;
    input_iterator mInputIterator;
    input_iterator mEnd;
    part_iterator mCurrent;
    std::vector<InputSpec> const& mFilterSpecs;
  };
 
  using const_iterator = Iterator<DataRef const>;
 
  const_iterator begin() const
  {
    return const_iterator(mRecord, mRecord.begin(), mRecord.end(), mFilterSpecs);
  }
 
  const_iterator end() const
  {
    return const_iterator(mRecord, mRecord.end(), mRecord.end(), mFilterSpecs);
  }
 
 private:
  InputRecord& mRecord;
  std::vector<InputSpec> mFilterSpecs;
};
 
} // namespace o2::framework
 
#endif // FRAMEWORK_INPUTRECORDWALKER_H