AltDataBucket.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_ALTDATABUCKET_H
#define ATHENASERVICES_ALTDATABUCKET_H
 
#include <cstdlib>  // std::abort
#include <memory>   // std::unique_ptr, std::make_unique
#include <string>   // std::string
#include <typeinfo> // std::type_info
 
// Framework include files
#include "AthenaKernel/DataBucketBase.h"
#include "AthenaKernel/IRegisterTransient.h"
#include "GaudiKernel/ClassID.h"
#include "SGTools/DataProxy.h"
#include "SGTools/TransientAddress.h"
 
namespace {
  class AltDataBucket
    : public DataBucketBase
  {
  public:
    AltDataBucket (void* ptr, CLID clid, const std::type_info& tinfo,
                   const SG::DataProxy& proxy)
      : m_proxy(this, makeTransientAddress(clid, proxy).release()),
        m_ptr (ptr), m_clid (clid), m_tinfo (tinfo)
    {
      addRef();
    }
    // Extra constructor to create a temporary proxy without aliases, for objects in MetaContainers
    AltDataBucket(void* ptr, CLID clid, const std::type_info& tinfo, const std::string& name) :
       m_proxy(this, new SG::TransientAddress(clid, name) ),
       m_ptr(ptr), m_clid(clid), m_tinfo(tinfo)
    {
      addRef();
    }
 
    virtual const CLID& clID() const override { return m_clid; }
    virtual void* object() override { return m_ptr; }
    virtual const std::type_info& tinfo() const override { return m_tinfo; }
    using DataBucketBase::cast;
    virtual void* cast (CLID /*clid*/,
                        SG::IRegisterTransient* /*irt*/ = nullptr,
                        bool /*isConst*/ = true) override
    { std::abort(); }
    virtual void* cast (const std::type_info& tinfo,
                        SG::IRegisterTransient* /*irt*/ = nullptr,
                        bool /*isConst*/ = true) override
    { if (tinfo == m_tinfo)
        return m_ptr;
      return nullptr;
    }
    virtual void relinquish() override {}
    virtual void lock() override {}
 
    
  private:
    static
    std::unique_ptr<SG::TransientAddress>
    makeTransientAddress (CLID clid, const SG::DataProxy& oldProxy);
 
    SG::DataProxy m_proxy;
    void* m_ptr;
    CLID  m_clid;
    const std::type_info& m_tinfo;
  };
 
 
  std::unique_ptr<SG::TransientAddress>
  AltDataBucket::makeTransientAddress (CLID clid, const SG::DataProxy& oldProxy)
  {
    auto newTad = std::make_unique<SG::TransientAddress>
      (clid, oldProxy.name());
    newTad->setAlias (oldProxy.alias());
    for (CLID tclid : oldProxy.transientID()) {
      // Note: this will include derived CLIDs.
      // Strictly speaking, that's not right; however, filtering them
      // out can break ElementLinks (for example those used by
      // ShallowAuxContainer).  One will not actually be able to get
      // a pointer of the derived type, as the conversions in StorableConversion
      // only support derived->base, not the other way around.
      newTad->setTransientID (tclid);
    }
    return newTad;
  }
 
} // anonymous namespace
 
#endif