ContainerMerge.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef XAODMUONVIEWS_MERGECONTAINER_H
#define XAODMUONVIEWS_MERGECONTAINER_H
 
#include "AthContainers/ConstDataVector.h"
#include "xAODMuonPrepData/MuonMeasurement.h"
#include "xAODMuonViews/IdentifierSorter.h"
#include "xAODMuonViews/FillContainer.h"
 
namespace xAOD{
    namespace detail {
        template <typename T>concept isMuonMeasurement  = std::is_base_of_v<xAOD::MuonMeasurement, T>;

        template <typename Cont_t> concept isMuonMeasurementCont = 
            PrimaryContainerConcept<Cont_t> &&
            std::is_base_of_v<xAOD::MuonMeasurement, typename Cont_t::base_value_type>;
 
    }
 

    template <detail::isMuonMeasurement inT,
              detail::isMuonMeasurementCont outT>
    void mergeInRange(typename DataVector<inT>::const_iterator begin,
                      const typename DataVector<inT>::const_iterator end,
                      ConstDataVector<outT>& outContainer) 
        requires(std::is_base_of_v<typename outT::base_value_type, inT>) {
        outContainer.reserve(std::distance(begin, end));
        if (outContainer.empty()) {
            outContainer.insert(outContainer.end(), begin, end);
            return;
        }
        MuonR4::IdentifierSorter sorter{};
        typename ConstDataVector<outT>::iterator outItr = outContainer.begin();
        for (; begin != end; ++begin){
            assert ((*begin) != nullptr);
#ifndef NDEBUG
            if (typename DataVector<inT>::const_iterator next = (begin +1); next != end) {
                assert ((*next) != nullptr);
                assert ((*begin)->identifierHash() <= (*next)->identifierHash());
            }
#endif
            outItr = std::find_if(outItr, outContainer.end(),
                                [&](const outT::base_value_type* obj){
                                    return !sorter(obj, *begin);
                                });
            outItr = outContainer.insert(outItr, *begin);
        }
    }

    template <detail::isMuonMeasurementCont outT,
              detail::isMuonMeasurement inT>
    void mergeContainer(ConstDataVector<outT>& outContainer,
                        const DataVector<inT>& inCont) {
        mergeInRange<inT>(inCont.begin(), inCont.end(), outContainer);
    }

    template <detail::isMuonMeasurementCont outT,
              detail::isMuonMeasurement inT1,
              detail::isMuonMeasurement inT2>
    void mergeContainer(ConstDataVector<outT>& outContainer,
                        const DataVector<inT1>& inCont1,
                        const DataVector<inT2>& inCont2) 
        requires(std::is_base_of_v<typename outT::base_value_type, inT1> &&
                 std::is_base_of_v<typename outT::base_value_type, inT2>){
        const std::size_t startSize = outContainer.size();
        outContainer.reserve(startSize + inCont1.size() + inCont2.size());
        typename DataVector<inT1>::const_iterator begin1 = inCont1.begin();
        typename DataVector<inT2>::const_iterator begin2 = inCont2.begin();
       
        const typename DataVector<inT1>::const_iterator end1 = inCont1.end();
        const typename DataVector<inT2>::const_iterator end2 = inCont2.end();
        MuonR4::IdentifierSorter sorter{};
        typename ConstDataVector<outT>::iterator insert = outContainer.begin();
        while ( begin1!= end1 || begin2 != end2) {
            if (begin1== end1) {
                mergeInRange<inT2>(begin2, end2, outContainer);
                break;
            } else if (begin2 == end2) {
                mergeInRange<inT1>(begin1, end1, outContainer);
                break;
            } else {
                const typename outT::base_value_type* mergeMe = nullptr;
                if (sorter(*begin1, *begin2)){
                    mergeMe = *begin1;
                    ++begin1;
                } else {
                    mergeMe = *begin2;
                    ++begin2;
                }
                insert = std::find_if(insert, outContainer.end(),
                                    [&](const outT::base_value_type* obj){
                                        return !sorter(obj, mergeMe);
                                    });
                insert = outContainer.insert(insert, mergeMe);
            }
        }
        assert(inCont1.size() + inCont2.size() + startSize == outContainer.size());
    }
}
 
 
#endif