IdentifiableContainerMT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EVENTCONTAINERS_IDENTIFIABLECONTAINERMT_H
#define EVENTCONTAINERS_IDENTIFIABLECONTAINERMT_H
 
#include "Identifier/Identifier.h"
#include "EventContainers/IIdentifiableCont.h"
#include <memory>
#include "GaudiKernel/DataObject.h"
#include "EventContainers/IdentifiableContainerBase.h"
#include "EventContainers/IDC_WriteHandleBase.h"
#include "CxxUtils/AthUnlikelyMacros.h"
#include "EventContainers/IdentifiableCache.h"
#include <bit>
#include <span>
#include <ranges>
 
template < class T>
class IdentifiableContainerMT : public DataObject, public EventContainers::IdentifiableContainerBase, public EventContainers::IIdentifiableCont<T>
{
 
public:
 
    class IDC_WriteHandle : EventContainers::IDC_WriteHandleBase {
        friend class IdentifiableContainerMT<T>;
        IdentifiableContainerMT<T> *m_IDC_ptr;
        IdentifierHash m_hashId;
        public:
        IDC_WriteHandle() : IDC_WriteHandleBase(), m_IDC_ptr(0), m_hashId(0) { }
        IDC_WriteHandle& operator=(const IDC_WriteHandle& other) = delete;
        IDC_WriteHandle(const IDC_WriteHandle& other) = delete;
        IDC_WriteHandle& operator=(IDC_WriteHandle&& other) noexcept = delete;
        static void Swap(IDC_WriteHandle& a, IDC_WriteHandle& b) noexcept {
           if(&a == &b) return;
           std::swap(a.m_IDC_ptr, b.m_IDC_ptr);
           std::swap(a.m_hashId, b.m_hashId);
           std::swap(a.m_atomic, b.m_atomic);
        }
        IDC_WriteHandle(IDC_WriteHandle&& other) : IDC_WriteHandle() {
           Swap(*this, other);
        }
 
        [[nodiscard]] StatusCode addOrDelete(std::unique_ptr<T> ptr){
           if(ATH_UNLIKELY(m_hashId >= m_IDC_ptr->m_link->fullSize())) return StatusCode::FAILURE;
           StatusCode sc = m_IDC_ptr->addLock(std::move(ptr), m_hashId);
           IDC_WriteHandleBase::ReleaseLock();
           return sc;
        }
        bool alreadyPresent() { return m_IDC_ptr->m_link->tryAddFromCache(m_hashId, *this); }
        bool OnlineAndPresentInAnotherView() { return m_IDC_ptr->m_OnlineMode && m_IDC_ptr->m_link->tryAddFromCache(m_hashId, *this); }
    };
 
 
 
    typedef T        IDENTIFIABLE;
    typedef EventContainers::IdentifiableCache<T> ICACHE;
    typedef IdentifiableContainerMT<T> MyType;
    typedef std::vector<std::atomic<const void*> >::size_type size_type;
    typedef T*&        reference;
    typedef T* const & const_reference;
    typedef T*         value_type;
    typedef T**        pointer;
    typedef T* const * const_pointer;
    typedef T          base_value_type;
 
 
    class const_iterator
    {
 
    public:

        const_iterator() : m_itr() {}
        const_iterator(const_iterator&&) = default;
        const_iterator(const const_iterator&) = default;
        const_iterator& operator = ( const const_iterator & ) = default; //move operators may be useful for shared_ptr
        const_iterator& operator = ( const_iterator && ) = default;
        ~const_iterator() = default;
 

        const_iterator& operator ++ () {
            ++m_itr;
            return *this;
        }

        const_iterator operator ++ ( int ) {
            const_iterator tmp = *this;
            ++*this;
            return tmp;
        }
 
        const T* cptr () const {
            return std::bit_cast<const T*>( m_itr->second );
        }
 
        const T* operator * () const {
            return std::bit_cast<const T*>( m_itr->second );
        }
 
        const T* operator ->() const { return (operator*()); }

        bool operator != ( const const_iterator &it ) const {
            return m_itr!= it.m_itr;
        }

        bool operator == ( const const_iterator &it ) const {
            return m_itr == it.m_itr;
        }

        //Calling this on an end iterator is undefined behaviour
        IdentifierHash hashId() const {
            return m_itr->first;
        }
 
    protected:
        friend class IdentifiableContainerMT<T>;
 
        const_iterator(EventContainers::I_InternalIDC::InternalConstItr itr) : m_itr(std::move(itr)) {}
 
 
        EventContainers::I_InternalIDC::InternalConstItr m_itr;
    };
 
    friend class IDC_WriteHandle;

    IdentifiableContainerMT(IdentifierHash hashMax);
 
    IdentifiableContainerMT(IdentifierHash hashMax, EventContainers::Mode);

    IdentifiableContainerMT(ICACHE *cache);
 
    ~IdentifiableContainerMT() { m_link->destructor(void_unique_ptr::Deleter<T>::deleter); }
 
    virtual bool hasExternalCache() const override final { return m_OnlineMode; }
 

    virtual const T* indexFindPtr( IdentifierHash hashId ) const override final;
 
    const_iterator indexFind( IdentifierHash hashId ) const {
        return m_link->indexFind(hashId);
    }

    virtual StatusCode addCollection(const T* coll, IdentifierHash hashId) override final;

    virtual StatusCode addOrDelete(std::unique_ptr<T>, IdentifierHash hashId) override final;
    virtual StatusCode addOrDelete(std::unique_ptr<const T>, IdentifierHash hashId) override final;

    StatusCode addOrDelete(std::unique_ptr<T>, IdentifierHash hashId, bool &deleted);

    StatusCode addLock(std::unique_ptr<T> ptr, IdentifierHash hashId);

    virtual bool tryAddFromCache(IdentifierHash hashId) override final;

    StatusCode fetchOrCreate(IdentifierHash hashId);
 
    StatusCode fetchOrCreate(const std::vector<IdentifierHash> &hashId);
 
    //This is a method to support bad behaviour in old code. Remove ASAP
    virtual StatusCode naughtyRetrieve ATLAS_NOT_THREAD_SAFE (IdentifierHash hashId, T* &collToRetrieve) const override final;
 

    T*  removeCollection(IdentifierHash hashId);

    virtual void cleanup() override final;

    virtual size_t fullSize() const  override final {
        return m_link->fullSize();
    }

    size_t size() const {
        return m_link->fullSize();
    }    
 
    void prepareItr() const { m_link->wait(); }

    virtual size_t numberOfCollections() const override final{
        return IdentifiableContainerBase::numberOfCollections();
    }
 
    auto GetAllHashPtrPair() const{
        static_assert(sizeof(const T*) == sizeof(const void*) && std::is_pointer<const T*>::value);
        static_assert(sizeof(EventContainers::hashPair<T>) == sizeof(EventContainers::hashPair<void>));
        const auto& void_vec = m_link->getAllHashPtrPair();  // std::vector<hashPair<void>>
        return void_vec | std::views::transform([](const auto& item) {
        // We construct a temporary hashPair<T> for each element
        return EventContainers::hashPair<T>{
            item.first,
            static_cast<const T*>(item.second)
        };
    });
    }
    
    virtual std::vector<IdentifierHash> GetAllCurrentHashes() const override final {
        return IdentifiableContainerBase::GetAllCurrentHashes();
    }

    const_iterator begin() const {
        return const_iterator(m_link->cbegin());
    }
 

    const_iterator end() const {
        return const_iterator(m_link->cend());
    }

    bool empty() const {
        return numberOfCollections()==0;
    }
 
    [[nodiscard]] IDC_WriteHandle getWriteHandle(IdentifierHash hash)
    {
       IDC_WriteHandle lock;
       lock.m_hashId = hash;
       lock.m_IDC_ptr = this;
       return lock;
    }
};
 
template < class T>
T*  //Please don't do this we want to get rid of this
IdentifiableContainerMT<T>::removeCollection( IdentifierHash hashId )
{
    return std::bit_cast<T*>(m_link->removeCollection(hashId));
}
 
 
 
// Constructor for OFFLINE style IDC
template < class T>
IdentifiableContainerMT<T>::IdentifiableContainerMT(IdentifierHash maxHash) :  IdentifiableContainerBase(maxHash)
{
}
 
template < class T>
IdentifiableContainerMT<T>::IdentifiableContainerMT(IdentifierHash maxHash, EventContainers::Mode mode) :
     IdentifiableContainerBase(maxHash, mode)
{
}
 
// Constructor for ONLINE style IDC
template < class T>
IdentifiableContainerMT<T>::IdentifiableContainerMT(ICACHE *cache) : IdentifiableContainerBase(cache)
{
}

template < class T>
const T*
IdentifiableContainerMT<T>::indexFindPtr( IdentifierHash hashId ) const
{
    return std::bit_cast<const T* > (IdentifiableContainerBase::indexFindPtr(hashId));
}
 
// insert collection into container with id hash
template < class T>
StatusCode
IdentifiableContainerMT<T>::addCollection(const T* coll, IdentifierHash hashId)
{
    // update m_hashids
    if (ATH_UNLIKELY(! IdentifiableContainerBase::insert(hashId, coll))) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 
}
 
 
 
template < class T>
void
IdentifiableContainerMT<T>::cleanup()
{
    IdentifiableContainerBase::cleanup(void_unique_ptr::Deleter<T>::deleter);
}
 
template < class T>
StatusCode
IdentifiableContainerMT<T>::fetchOrCreate(IdentifierHash hashId)
{
    return IdentifiableContainerBase::fetchOrCreate(hashId);
}
 
template < class T>
StatusCode
IdentifiableContainerMT<T>::fetchOrCreate(const std::vector<IdentifierHash> &hashIds)
{
    return IdentifiableContainerBase::fetchOrCreate(hashIds);
}
 
 
template < class T>
bool
IdentifiableContainerMT<T>::tryAddFromCache(IdentifierHash hashId)
{
    return IdentifiableContainerBase::tryAddFromCache(hashId);
}
 
template < class T >
StatusCode 
IdentifiableContainerMT<T>::naughtyRetrieve(IdentifierHash hashId, T* &collToRetrieve) const
{
   if(ATH_UNLIKELY(m_OnlineMode)) return StatusCode::FAILURE;//NEVER ALLOW FOR EXTERNAL CACHE
   else {
      auto p = std::bit_cast<const T* > (m_link->findIndexPtr(hashId));//collToRetrieve can be null on success
      collToRetrieve = const_cast<T*>(p);
      return StatusCode::SUCCESS;
   }
}
 
template < class T>
StatusCode
IdentifiableContainerMT<T>::addOrDelete(std::unique_ptr<T> uptr, IdentifierHash hashId)
{
    if(ATH_UNLIKELY(hashId >= m_link->fullSize())) return StatusCode::FAILURE;
    auto ptr = uptr.release();
    bool b = IdentifiableContainerBase::insert(hashId, ptr);
    if(!b) delete ptr;
    return StatusCode::SUCCESS;
}
 
template < class T>
StatusCode
IdentifiableContainerMT<T>::addOrDelete(std::unique_ptr<const T> uptr, IdentifierHash hashId)
{
    if(ATH_UNLIKELY(hashId >= m_link->fullSize())) return StatusCode::FAILURE;
    auto ptr = uptr.release();
    bool b = IdentifiableContainerBase::insert(hashId, ptr);
    if(!b) delete ptr;
    return StatusCode::SUCCESS;
}
 
template < class T>
StatusCode
IdentifiableContainerMT<T>::addLock(std::unique_ptr<T> ptr, IdentifierHash hashId)
{
    return m_link->addLock(hashId, ptr.release());
}
 
template < class T>
StatusCode
IdentifiableContainerMT<T>::addOrDelete(std::unique_ptr<T> uptr, IdentifierHash hashId, bool &deleted)
{
    if(ATH_UNLIKELY(hashId >= m_link->fullSize())) return StatusCode::FAILURE;
    auto ptr = uptr.release();
    bool b = IdentifiableContainerBase::insert(hashId, ptr);
    if(!b) delete ptr;
    deleted = !b;
    return StatusCode::SUCCESS;
}
 
#endif