DBImportArray.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Marko Staric                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <framework/database/DBImportBase.h>
#include <framework/utilities/ArrayIterator.h>
#include <TClonesArray.h>
#include <stdexcept>
 
namespace Belle2 {
  template<class T> class DBImportArray: public  DBImportBase {
  public:
 
    typedef ObjArrayIterator<TClonesArray, T> iterator;
    typedef ObjArrayIterator<const TClonesArray, const T> const_iterator;
 
    explicit DBImportArray(const std::string& name = ""):
      DBImportBase(DBStore::arrayName<T>(name))
    {
      m_object = new TClonesArray(T::Class());
    }
 
    ~DBImportArray()
    {
      delete m_object;
    }
 
    inline int getEntries() const
    {
      return static_cast<TClonesArray*>(m_object)->GetEntriesFast();
    }
 
    inline T* appendNew() { return new(nextFreeAdress()) T(); }
 
    template<class ...Args> T* appendNew(Args&& ... params)
    {
      return new(nextFreeAdress()) T(std::forward<Args>(params)...);
    }
 
    inline T* operator [](int i) const
    {
      TObject* obj = static_cast<TClonesArray*>(m_object)->At(i);
      if (obj == nullptr)
        throw std::out_of_range("Out-of-range access in DBImportArray::operator[], for "
                                + getName() + ", index "
                                + std::to_string(i));
      return static_cast<T*>(obj);
    }
 
    iterator begin() { return iterator(*static_cast<TClonesArray*>(m_object), 0); }
 
    iterator end() { return iterator(*static_cast<TClonesArray*>(m_object), getEntries()); }
 
    const_iterator begin() const { return const_iterator(*static_cast<TClonesArray*>(m_object), 0); }
 
    const_iterator end() const { return const_iterator(*static_cast<TClonesArray*>(m_object), getEntries()); }
 
    void addEventDependency(unsigned int eventNumber) override
    {
      addIntraRunDependency(eventNumber, c_Event);
      m_object = new TClonesArray(T::Class());
    }
 
    void addTimeStampDependency(unsigned long long int timeStamp) override
    {
      addIntraRunDependency(timeStamp, c_TimeStamp);
      m_object = new TClonesArray(T::Class());
    }
 
    void addSubrunDependency(int subrun) override
    {
      addIntraRunDependency(subrun, c_Subrun);
      m_object = new TClonesArray(T::Class());
    }
 
    void clear() override
    {
      DBImportBase::clear();
      m_object = new TClonesArray(T::Class());
    }
 
 
  private:
 
    inline T* nextFreeAdress()
    {
      return static_cast<T*>(static_cast<TClonesArray*>(m_object)->AddrAt(getEntries()));
    }
 
  };
}