xAODTestShallowCopy.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "xAODTestShallowCopy.h"
#include "DataModelTestDataCommon/CVec.h"
#include "DataModelTestDataCommon/CVecWithData.h"
#include "DataModelTestDataCommon/C.h"
#include "DataModelTestDataCommon/CAuxContainer.h"
#include "DataModelTestDataCommon/CTrigAuxContainer.h"
#include "DataModelTestDataCommon/CInfoAuxContainer.h"
#include "xAODCore/ShallowCopy.h"
#include "StoreGate/ReadHandle.h"
#include "StoreGate/WriteHandle.h"
#include "StoreGate/WriteDecorHandle.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthenaKernel/errorcheck.h"
 
 
namespace DMTest {
 

StatusCode xAODTestShallowCopy::initialize()
{
  if (m_cvecReadKey.empty()) {
    m_cvecWriteKey = "";
    m_cvecAnInt10Key = "";
  }
  ATH_CHECK( m_cvecReadKey.initialize( !m_cvecReadKey.empty() ) );
  ATH_CHECK( m_cvecWriteKey.initialize( !m_cvecReadKey.empty() ) );
  ATH_CHECK( m_cvecAnInt10Key.initialize( !m_cvecReadKey.empty() ) );
  ATH_CHECK( m_cvecDecorDeps.initialize( m_cvecReadKey, m_cvecWriteKey, !m_cvecReadKey.empty() ) );
 
  if (m_cvecWDReadKey.empty()) {
    m_cvecWDWriteKey = "";
    m_cvecWDAnInt10Key = "";
  }
  ATH_CHECK( m_cvecWDReadKey.initialize( !m_cvecWDReadKey.empty() ) );
  ATH_CHECK( m_cvecWDWriteKey.initialize( !m_cvecWDReadKey.empty() ) );
  ATH_CHECK( m_cvecWDAnInt10Key.initialize( !m_cvecWDReadKey.empty() ) );
  ATH_CHECK( m_cvecWDDecorDeps.initialize( m_cvecWDReadKey, m_cvecWDWriteKey, !m_cvecWDReadKey.empty() ) );
 
  if (m_cinfoReadKey.empty()) {
    m_cinfoWriteKey = "";
    m_cinfoAnInt10Key = "";
  }
  ATH_CHECK( m_cinfoReadKey.initialize( !m_cinfoReadKey.empty() ) );
  ATH_CHECK( m_cinfoWriteKey.initialize( !m_cinfoReadKey.empty() ) );
  ATH_CHECK( m_cinfoAnInt10Key.initialize( !m_cinfoReadKey.empty() ) );
  ATH_CHECK( m_cinfoDecorDeps.initialize( m_cinfoReadKey, m_cinfoWriteKey, !m_cinfoReadKey.empty() ) );
 
  if (m_cinfoReadKeyBase.empty()) {
    m_cinfoWriteKeyBase = "";
  }
  ATH_CHECK( m_cinfoReadKeyBase.initialize( !m_cinfoReadKeyBase.empty() ) );
  ATH_CHECK( m_cinfoWriteKeyBase.initialize( !m_cinfoReadKeyBase.empty() ) );
  ATH_CHECK( m_cinfoDecorDepsBase.initialize( m_cinfoReadKeyBase, m_cinfoWriteKeyBase, !m_cinfoReadKeyBase.empty() ) );
 
  if (m_ctrigReadKey.empty()) {
    m_ctrigWriteKey = "";
    m_ctrigAnInt10Key = "";
  }
  ATH_CHECK( m_ctrigReadKey.initialize( !m_ctrigReadKey.empty() ) );
  ATH_CHECK( m_ctrigWriteKey.initialize( !m_ctrigReadKey.empty() ) );
  ATH_CHECK( m_ctrigAnInt10Key.initialize( !m_ctrigReadKey.empty() ) );
  ATH_CHECK( m_ctrigDecorDeps.initialize( m_ctrigReadKey, m_ctrigWriteKey, !m_ctrigReadKey.empty() ) );
 
  return StatusCode::SUCCESS;
}
 

StatusCode xAODTestShallowCopy::execute (const EventContext& ctx) const
{
  int count = ctx.evt() + 1;
 
  if (!m_cvecReadKey.empty()) {
    SG::ReadHandle<CVec> vec (m_cvecReadKey, ctx);
    auto ret = xAOD::shallowCopy (*vec, ctx);
 
    SG::WriteHandle<DMTest::CVec> copy (m_cvecWriteKey, ctx);
    ATH_CHECK( copy.record (std::move(ret.first), std::move(ret.second)) );
 
    ATH_CHECK( m_cvecDecorDeps.linkDecors (m_cvecReadKey, ctx) );
 
    SG::WriteDecorHandle<DMTest::CVec, int> anInt10 (m_cvecAnInt10Key, ctx);
    for (C* c : *copy)
      anInt10(*c) = count * 20000 + c->anInt() * 100;
  }
 
  if (!m_cvecWDReadKey.empty()) {
    SG::ReadHandle<CVecWithData> vec (m_cvecWDReadKey, ctx);
    auto ret = xAOD::shallowCopy (*vec, ctx);
    ret.first->meta1 = vec->meta1;
 
    SG::WriteHandle<DMTest::CVecWithData> copy (m_cvecWDWriteKey, ctx);
    ATH_CHECK( copy.record (std::move(ret.first), std::move(ret.second)) );
 
    ATH_CHECK( m_cvecWDDecorDeps.linkDecors (m_cvecWDReadKey, ctx) );
 
    SG::WriteDecorHandle<DMTest::CVecWithData, int> anInt10 (m_cvecWDAnInt10Key, ctx);
    for (C* c : *copy)
      anInt10(*c) = count * 20000 + c->anInt() * 100;
  }
 
  if (!m_cinfoReadKey.empty()) {
    SG::ReadHandle<DMTest::C> cinfo (m_cinfoReadKey, ctx);
    auto ret = xAOD::shallowCopy (*cinfo, ctx);
 
    SG::WriteHandle<DMTest::C> copy (m_cinfoWriteKey, ctx);
    ATH_CHECK( copy.record (std::move(ret.first), std::move(ret.second)) );
 
    ATH_CHECK( m_cinfoDecorDeps.linkDecors (m_cinfoReadKey, ctx) );
 
    SG::WriteDecorHandle<DMTest::C, int> anInt10 (m_cinfoAnInt10Key, ctx);
    anInt10(*copy) = count * 20000 + copy->anInt() * 200;
  }
 
  if (!m_cinfoReadKeyBase.empty()) {
    ATH_CHECK( m_cinfoDecorDepsBase.linkDecors (m_cinfoReadKeyBase, ctx) );
  }
 
  if (!m_ctrigReadKey.empty()) {
    SG::ReadHandle<CVec> ctrig (m_ctrigReadKey, ctx);
    auto ret = xAOD::shallowCopy (*ctrig, ctx);
 
    SG::WriteHandle<DMTest::CVec> copy (m_ctrigWriteKey, ctx);
    ATH_CHECK( copy.record (std::move(ret.first), std::move(ret.second)) );
 
    ATH_CHECK( m_ctrigDecorDeps.linkDecors (m_ctrigReadKey, ctx) );
 
    SG::WriteDecorHandle<DMTest::CVec, int> anInt10 (m_ctrigAnInt10Key, ctx);
    for (C* c : *copy)
      anInt10(*c) = count * 20000 + c->anInt() * 300;
  }
 
  return StatusCode::SUCCESS;
}
 
 
} // namespace DMTest