ContainerDecorator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef XAODMUONVIEWS_CONTAINERDECORATOR_H
#define XAODMUONVIEWS_CONTAINERDECORATOR_H
#include "StoreGate/WriteDecorHandleKey.h"
#include "StoreGate/WriteDecorHandleKeyArray.h"
#include "StoreGate/WriteDecorHandle.h"
#include "AthContainers/AuxElement.h"
#include "xAODMuonViews/FillContainer.h"
#include <unordered_set>
 
namespace xAOD{
    template<detail::PrimaryContainerConcept Cont_t, typename dType>
    class ContainerDecorator {
        public:
            using Handle_t = SG::WriteDecorHandle<Cont_t, dType>;
            explicit ContainerDecorator() = default;
            explicit ContainerDecorator(const SG::WriteDecorHandleKey<Cont_t>& key,
                                        const EventContext& ctx,
                                        dType defValue = {}) {
                initialize(key, ctx, std::move(defValue));
            }

            ~ContainerDecorator()  {
                initDefault();
            }

            ContainerDecorator(ContainerDecorator&& other) = default;
            ContainerDecorator& operator=(ContainerDecorator&& other) = default;

            void initialize(const SG::WriteDecorHandleKey<Cont_t>& key,
                            const EventContext& ctx,
                            dType defValue = {}) {
                if (key.empty()) {
                    m_decorHandle.reset();
                    return;
                }
                if (m_decorHandle) {
                    THROW_EXCEPTION("The Container decorator is already initialized to "<<m_decorHandle->fullKey()<<"."
                                <<m_decorHandle->decorKey());
                }
                m_decorHandle = std::make_unique<Handle_t>(key, ctx);
                m_defValue = std::move(defValue);
                initDefault();
            }

            dType& operator()(const SG::AuxElement& auxElem) {
                if (ATH_UNLIKELY(!m_decorHandle)) {
                    THROW_EXCEPTION("No decorator has been defined. Please use initialize() beforhand");
                }
                m_seenAux.insert(&auxElem);
                return (*m_decorHandle)(auxElem);
            }

            constexpr bool isValid() const { return m_decorHandle != nullptr; }
            constexpr operator bool () const {return isValid(); }
            const Cont_t* container() const { return isValid() ? m_decorHandle->cptr() : nullptr; }
            const Cont_t* operator->() const { return container(); }
        private:
            void initDefault() {
                if (!m_decorHandle){
                    return;
                } 
                if(!m_decorHandle->isPresent() ) {
                    return;
                }
                for (const SG::AuxElement* auxElem : **m_decorHandle) {
                    if (m_seenAux.insert(auxElem).second) {
                        (*m_decorHandle)(*auxElem) = m_defValue;
                    }
                }
            }
            std::unique_ptr<Handle_t> m_decorHandle{};
            std::unordered_set<const SG::AuxElement*> m_seenAux{};
            dType m_defValue{};
    };

    template<detail::PrimaryContainerConcept Cont_t, typename dType>
    std::vector<ContainerDecorator<Cont_t, dType>> createDecorators(const SG::WriteDecorHandleKeyArray<Cont_t>& keyArray,
                                                                    const EventContext& ctx,
                                                                    dType defValue = {}) {
        std::vector<ContainerDecorator<Cont_t, dType>> retMe{};
        for (const SG::WriteDecorHandleKey<Cont_t>& key : keyArray) {
            retMe.emplace_back(key, ctx, defValue);
        }
        return retMe;
    }
}
 
#endif