FillContainer.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef XAODMUONVIEWS_FILLCONTAINER_H
#define XAODMUONVIEWS_FILLCONTAINER_H
 
#include "xAODCore/AuxContainerBase.h"
#include "AthContainers/DataVector.h"
#include "AthContainers/AuxElement.h"
#include "GaudiKernel/MsgStream.h"
#include "AthenaKernel/getMessageSvc.h"
#include "GeoModelKernel/throwExcept.h"
#include "StoreGate/WriteHandle.h"
 
#include <concepts>
namespace xAOD {

namespace detail{
     template <typename AuxCont_t> concept AuxContainerConcept = std::is_base_of_v<xAOD::AuxContainerBase, AuxCont_t>
                                                              || std::is_same_v<AuxCont_t, void*>;
    template<typename Cont_t> concept DataVectorConcept = 
        std::is_same_v<Cont_t, DataVector<typename Cont_t::base_value_type>>;
    template <typename Cont_t> concept PrimaryContainerConcept = DataVectorConcept<Cont_t> 
                                                              && requires(const Cont_t& container) {
        requires std::is_base_of_v<SG::AuxElement, typename Cont_t::base_value_type>;
    };
}
 
 
template <detail::DataVectorConcept Cont_t, 
          detail::AuxContainerConcept AuxCont_t>
class FillContainer {
    public:
        using WriteHandle_t = SG::WriteHandle<Cont_t>;
        FillContainer() {
            static_assert( (detail::PrimaryContainerConcept<Cont_t> && !std::is_same_v<AuxCont_t, void*>) ||
                           (detail::DataVectorConcept<Cont_t> && std::is_same_v<AuxCont_t, void*>));
            if constexpr(!std::is_same_v<AuxCont_t, void*>) {
                m_cont->setStore(m_auxCont.get());
            }
        }

        FillContainer(FillContainer&& other) = default;
        FillContainer& operator=(FillContainer&& other) = default;
        Cont_t* get() const { 
            if (!hasHandle()) {
                return m_cont.get();
            }
            WriteHandle_t& handle ATLAS_THREAD_SAFE{*m_writeHandle};
            return handle.ptr(); 
        }

        Cont_t* operator->() const { return  get(); }
        Cont_t& operator*() const { return *get(); }
        StatusCode record(const SG::WriteHandleKey<Cont_t>& key,
                          const EventContext& ctx) {
            if (key.empty()) {
                return StatusCode::SUCCESS;
            }
            if (hasHandle()) {
                MsgStream msg{Athena::getMessageSvc(), "FillContainer"};
                msg<<MSG::ERROR<<__func__<<"() - "<<__LINE__<<": Write handle under key "
                    <<m_writeHandle->key()<<" already exists."<<endmsg;
                return StatusCode::FAILURE;
            }
            m_writeHandle = std::make_unique<WriteHandle_t>(key, ctx);
            if constexpr(!std::is_same_v<AuxCont_t, void*>) {
                return m_writeHandle->record(std::move(m_cont), std::move(m_auxCont));
            } else {
                return m_writeHandle->record(std::move(m_cont));
            }
        }

        StatusCode recordNonConst(const SG::WriteHandleKey<Cont_t>& key,
                                  const EventContext& ctx) {
            if (key.empty()) {
                return StatusCode::SUCCESS;
            }
            if (hasHandle()) {
                MsgStream msg{Athena::getMessageSvc(), "FillContainer"};
                msg<<MSG::ERROR<<__func__<<"() - "<<__LINE__<<": Write handle under key "
                    <<m_writeHandle->key()<<" already exists."<<endmsg;
                return StatusCode::FAILURE;
            }
            m_writeHandle = std::make_unique<WriteHandle_t>(key, ctx);
            if constexpr(!std::is_same_v<AuxCont_t, void*>) {
                return m_writeHandle->recordNonConst(std::move(m_cont), std::move(m_auxCont));
            } else {
                return m_writeHandle->recordNonConst(std::move(m_cont));
            }
        }

        WriteHandle_t& getHandle() {
            if (!hasHandle()) {
                THROW_EXCEPTION("The write handle has not been initialized. Please call record or"
                              <<" recordNonConst before calling getHandle()");
            }
            return *m_writeHandle;
        }

        bool hasHandle() const { return m_writeHandle != nullptr; }
    private:
        std::unique_ptr<Cont_t> m_cont{std::make_unique<Cont_t>()};
        std::unique_ptr<AuxCont_t> m_auxCont{std::make_unique<AuxCont_t>()};
        std::unique_ptr<WriteHandle_t> m_writeHandle{};
};
 
}
#endif