StoreArray.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/StoreAccessorBase.h>
#include <framework/datastore/DataStore.h>
 
#include <framework/utilities/ArrayIterator.h>
 
#include <TClonesArray.h>
#include <stdexcept>
 
namespace Belle2 {
  namespace _StoreArrayImpl {
    void clearRelations(const StoreAccessorBase& array);
  };

  template <class T>
  class StoreArray : public StoreAccessorBase {
  public:
    typedef ObjArrayIterator<TClonesArray, T> iterator;
    typedef ObjArrayIterator<const TClonesArray, const T> const_iterator;

    explicit StoreArray(const std::string& name = "", DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(DataStore::arrayName<T>(name), durability, T::Class(), true), m_storeArray(0) {}
 

    template <class TO> bool registerRelationTo(const StoreArray<TO>& toArray, DataStore::EDurability durability = DataStore::c_Event,
                                                DataStore::EStoreFlags storeFlags = DataStore::c_WriteOut, const std::string& namedRelation = "") const
    {
      return DataStore::Instance().registerRelation(*this, toArray, durability, storeFlags, namedRelation);
    }

    template <class TO> bool requireRelationTo(const StoreArray<TO>& toArray,
                                               DataStore::EDurability durability = DataStore::c_Event,
                                               const std::string& namedRelation = "") const
    {
      return DataStore::Instance().requireRelation(*this, toArray, durability, namedRelation);
    }

    template <class TO> bool optionalRelationTo(const StoreArray<TO>& toArray,
                                                DataStore::EDurability durability = DataStore::c_Event,
                                                const std::string& namedRelation = "") const
    {
      return DataStore::Instance().optionalRelation(*this, toArray, durability, namedRelation);
    }

    template <class TO> bool hasRelationTo(const StoreArray<TO>& toArray, DataStore::EDurability durability = DataStore::c_Event,
                                           const std::string& namedRelation = "") const
    {
      return DataStore::Instance().hasRelation(*this, toArray, durability, namedRelation);
    }

    template <class FROM> bool hasRelationFrom(const StoreArray<FROM>& fromArray,
                                               DataStore::EDurability durability = DataStore::c_Event, const std::string& namedRelation = "") const
    {
      return DataStore::Instance().hasRelation(fromArray, *this, durability, namedRelation);
    }

    void clear() override
    {
      if (getEntries() != 0) {
        (*m_storeArray)->Delete();
        _StoreArrayImpl::clearRelations(*this);
      }
    }

    inline int getEntries() const { return isCreated() ? ((*m_storeArray)->GetEntriesFast()) : 0;}

    inline T* operator [](int i) const
    {
      ensureCreated();
      //At() checks for out-of-range and returns NULL in that case
      //type was checked by DataStore, so the cast is safe.
      T* obj = static_cast<T*>((*m_storeArray)->At(i));
      if (obj == nullptr)
        throw std::out_of_range("Out-of-range access in StoreArray::operator[], for " + readableName() + ", index " + std::to_string(i));
      return obj;
    }

    inline T* appendNew() { return new (nextFreeAdress()) T(); }

    template<class ...Args> T* appendNew(Args&& ... params)
    {
      return new (nextFreeAdress()) T(std::forward<Args>(params)...);
    }
 

    static std::vector<std::string> getArrayList(DataStore::EDurability durability = DataStore::c_Event)
    {
      return DataStore::Instance().getListOfArrays(T::Class(), durability);
    }
 

    inline bool isValid() const
    {
      ensureAttached();
      return m_storeArray;
    }

    inline operator bool() const { return isValid(); }

    TClonesArray* getPtr() const
    {
      ensureCreated();
      return (m_storeArray ? *m_storeArray : nullptr);
    }

    iterator begin() { ensureAttached(); return iterator(m_storeArray); }
    iterator end() { ensureAttached(); return iterator(m_storeArray, true); }

    const_iterator begin() const { ensureAttached(); return const_iterator(m_storeArray); }
    const_iterator end() const { ensureAttached(); return const_iterator(m_storeArray, true); }
 
  private:
    // cppcheck-suppress duplInheritedMember ; intentionally hides the base class member
    bool create(bool replace = false) { return StoreAccessorBase::create(replace); }

    inline T* nextFreeAdress()
    {
      ensureCreated();
      return static_cast<T*>((*m_storeArray)->AddrAt(getEntries()));
    }

    inline void ensureAttached() const
    {
      if (!m_storeArray) {
        const_cast<StoreArray*>(this)->m_storeArray = reinterpret_cast<TClonesArray**>(DataStore::Instance().getObject(*this));
      }
    }

    inline void ensureCreated() const
    {
      if (!isCreated()) {
        if (!const_cast<StoreArray*>(this)->create())
          throw std::runtime_error("Write access to " + readableName() + " failed, did you remember to call registerInDataStore()?");
      }
    }

    inline bool isCreated() const
    {
      ensureAttached();
      return m_storeArray && *m_storeArray;
    }

    TClonesArray** m_storeArray;
 
  };

} // end namespace Belle2