AuxElement.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "AthContainers/AuxElement.h"
#include "AthContainers/AuxStoreStandalone.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/tools/error.h"
#include "CxxUtils/checker_macros.h"
#include <sstream>
 
 
namespace SG {
 

class AuxElementData
  : public AuxVectorData
{
public:
  virtual size_t size_v() const override { return 1; }
  virtual size_t capacity_v() const override { return 1; }
};
 

class AuxElementPrivateData
  : public AuxElementData
{
public:
  AuxElementPrivateData ()
  {
    this->setStore (&m_store);
  }
 
 
private:
  AuxStoreStandalone m_store;
};
 

class AuxElementStandaloneData
  : public AuxElementData
{
public:
  using AuxElementData::setStore;
};
 
 
//************************************************************************
 

void ConstAuxElement::releasePrivateStoreForDtor()
{
  if (havePrivateData()) {
    delete m_container;
  }
}
 

bool ConstAuxElement::setIndexPrivate (size_t index,
                                       const SG::AuxVectorData* container)
{
  if (hadPrivateData()) {
    // We had a private store, but it was released because we were added
    // to a container.
 
    if (container == 0) {
      // We're being moved out of the container.  Make a new private
      // store, copy the data, and switch to it.
      auto privateData = new SG::AuxElementPrivateData;
      AuxElement to (privateData, 0);
      to.copyAux (*this);
      IAuxElement::setIndex (0);
      IAuxElement::setHavePrivateData();
      m_container = privateData;
      return true;
    }
  }
  else if (havePrivateData() &&
           typeid(*m_container) == typeid(AuxElementPrivateData))
  {
    // We currently have a private store.
 
    if (container != 0 && container != m_container) {
      // We're being added to a container.
      // Aux data has already been copied.
      // Release private store.
      IAuxElement::setIndex (index);
      IAuxElement::setHadPrivateData();
      delete m_container;
      m_container = container;
      return false;
    }
  }
  else {
    // We have a standalone store.
    throw SG::ExcBadPrivateStore ("Attempt to add/remove a standalone object "
                                  "from a container.");
  }
 
  IAuxElement::setIndex (index);
  m_container = container;
  return false;
}
 

const SG::auxid_set_t& ConstAuxElement::getAuxIDs() const
{
  if (havePrivateData())
    return m_container->getConstStore()->getAuxIDs();
  if (container())
    return container()->getAuxIDs();
  static const SG::auxid_set_t null_set;
  return null_set;
}
 

const SG::auxid_set_t& ConstAuxElement::getDecorIDs() const
{
  if (havePrivateData())
    return m_container->getConstStore()->getDecorIDs();
  if (container())
    return container()->getDecorIDs();
  static const SG::auxid_set_t null_set;
  return null_set;
}
 
 
//************************************************************************
 

void AuxElement::makePrivateStore()
{
  if (m_container) {
    throw SG::ExcBadPrivateStore ("store already exists");
  }
 
  m_container = new SG::AuxElementPrivateData;
  IAuxElement::setIndex (0);
  IAuxElement::setHavePrivateData();
}
 

void AuxElement::releasePrivateStore()
{
  if (hadPrivateData()) {
    // We had a private store, but it was released because this object
    // was added to a container.  Just forget about it.
    IAuxElement::setNoPrivateData();
    return;
  }
 
  if (!havePrivateData() ||
      !m_container ||
      typeid(*m_container) != typeid(AuxElementPrivateData))
  {
    throw SG::ExcBadPrivateStore ("no private store exists");
  }
 
  IAuxElement::setIndex (0);
  IAuxElement::setNoPrivateData();
  delete m_container;
  m_container = 0;
}
 

void AuxElement::setStore (const SG::IConstAuxStore* store)
{
  AuxElementStandaloneData* data = setStore1 (store);
  if (store)
    data->setStore (store);
}
 

void AuxElement::setStore (SG::IAuxStore* store)
{
  AuxElementStandaloneData* data = setStore1 (store);
  if (store)
    data->setStore (store);
}
 

void AuxElement::setStore (const DataLink< SG::IConstAuxStore >& store)
{
  AuxElementStandaloneData* data = setStore1 (store);
  if (store)
    data->setStore (store);
}
 

bool AuxElement::usingPrivateStore() const
{
  return havePrivateData() && 
    typeid(*m_container) == typeid(AuxElementPrivateData);
}
 

bool AuxElement::usingStandaloneStore() const
{
  return havePrivateData() &&
    typeid(*m_container) == typeid(AuxElementStandaloneData);
}
 

const SG::IConstAuxStore* AuxElement::getConstStore() const
{
  if (havePrivateData()) {
    return m_container->getConstStore();
  }
  return 0;
}
 

SG::IAuxStore* AuxElement::getStore() const
{
  if (havePrivateData()) {
#ifdef ATHCONTAINERS_R21_COMPAT
    SG::AuxVectorData* container_nc ATLAS_THREAD_SAFE = m_container;
#else
    SG::AuxVectorData* container_nc ATLAS_THREAD_SAFE = const_cast<SG::AuxVectorData*>(container());
#endif
    return container_nc->getStore();
  }
  return 0;
}
 

void AuxElement::clearCache()
{
  if (container())
    container()->clearCache();
}
 

const SG::auxid_set_t& AuxElement::getAuxIDs() const
{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (havePrivateData())
    return m_container->getConstStore()->getAuxIDs();
  if (container())
    return container()->getAuxIDs();
  static const SG::auxid_set_t null_set;
  return null_set;
#else
  return ConstAuxElement::getAuxIDs();
#endif
}
 

const SG::auxid_set_t& AuxElement::getDecorIDs() const
{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (havePrivateData())
    return m_container->getConstStore()->getDecorIDs();
  if (container())
    return container()->getDecorIDs();
  static const SG::auxid_set_t null_set;
  return null_set;
#else
  return ConstAuxElement::getDecorIDs();
#endif
}
 

bool AuxElement::hasStore() const
{
  if (havePrivateData())
    return m_container->hasStore();
  return false;
}
 

bool AuxElement::hasNonConstStore() const
{
  if (havePrivateData())
    return m_container->hasNonConstStore();
  return false;
}
 

bool AuxElement::clearDecorations() const
{
  if (havePrivateData())
    return m_container->clearDecorations();
  return false;
}
 

void AuxElement::releasePrivateStoreForDtor()
{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (havePrivateData()) {
    delete m_container;
  }
#else
  ConstAuxElement::releasePrivateStoreForDtor();
#endif
}
 

AuxElementStandaloneData*
AuxElement::setStore1 (const SG::IConstAuxStore* store)
{
  if (store) {
    // Want this object be standalone.
    if (!m_container) {
      // Not in a container (and no private store).  Make a new object.
      AuxElementStandaloneData* data = new AuxElementStandaloneData;
      IAuxElement::setHavePrivateData();
      m_container = data;
      return data;
    }
    if (usingStandaloneStore()) {
      // Standalone --- return existing object.
      return static_cast<AuxElementStandaloneData*> (container());
    }
    // Otherwise, it's an error.
    throw ExcBadPrivateStore ("Attempt to attach a standalone store to an "
                              "object in a container or with a private store.");
  }
 
  else {
    // Getting rid of a standalone store.
    if (usingStandaloneStore()) {
      IAuxElement::setNoPrivateData();
      delete m_container;
      m_container = 0;
    }
    else if (m_container != 0)
      throw ExcBadPrivateStore ("Attempt to remove a standalone store from an "
                                "object in a container or with a private store.");
    return 0;
  }
}
 

bool AuxElement::setIndexPrivate (size_t index, SG::AuxVectorData* container)
{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (hadPrivateData()) {
    // We had a private store, but it was released because we were added
    // to a container.
 
    if (container == 0) {
      // We're being moved out of the container.  Make a new private
      // store, copy the data, and switch to it.
      auto privateData = new SG::AuxElementPrivateData;
      AuxElement to (privateData, 0);
      to.copyAux (*this);
      IAuxElement::setIndex (0);
      IAuxElement::setHavePrivateData();
      m_container = privateData;
      return true;
    }
  }
  else if (havePrivateData() &&
           typeid(*m_container) == typeid(AuxElementPrivateData))
  {
    // We currently have a private store.
 
    if (container != 0 && container != m_container) {
      // We're being added to a container.
      // Aux data has already been copied.
      // Release private store.
      IAuxElement::setIndex (index);
      IAuxElement::setHadPrivateData();
      delete m_container;
      m_container = container;
      return false;
    }
  }
  else {
    // We have a standalone store.
    throw SG::ExcBadPrivateStore ("Attempt to add/remove a standalone object "
                                  "from a container.");
  }
 
  IAuxElement::setIndex (index);
  m_container = container;
  return false;
#else
  return ConstAuxElement::setIndexPrivate (index, container);
#endif
}
 

void AuxElement::makePrivateStore1 (const AuxElement* other,
                                    bool warnUnlocked)
{
  makePrivateStore();
  if (other)
    this->copyAux (*other, warnUnlocked);
}
 

void AuxElement::clearAux()
{
  if (!m_container) return;
  clearAuxHelper (*container(), index());
}
 

void AuxElement::copyAux (const ConstAuxElement& other,
                          bool warnUnlocked /*= false*/)
{
  if (!m_container) return;
  copyAuxHelper (*container(), index(), other, warnUnlocked);
}
 
 
#ifdef ATHCONTAINERS_R21_COMPAT
void AuxElement::copyAux (const AuxElement& other,
                          bool warnUnlocked /*= false*/)
{
  if (!m_container) return;
  copyAuxHelper (*container(), index(), other, warnUnlocked);
}
#endif
 
 

void AuxElement::clearAuxHelper (AuxVectorData& container, size_t index)
{
  if (!container.hasStore()) return;
  if (!container.hasNonConstStore()) {
    throw SG::ExcConstAuxData ("clearAux", SG::null_auxid);
  }
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  for (SG::auxid_t auxid : container.getWritableAuxIDs()) {
    r.clear (auxid, container, index, 1);
  }
}
 

void AuxElement::copyAuxHelper (AuxVectorData& container,
                                size_t index,
                                const ConstAuxElement& other,
                                [[maybe_unused]] bool warnUnlocked)
{
  if (!container.hasStore()) return;
  if (!container.hasNonConstStore())
    throw SG::ExcConstAuxData ("copyAux");
 
  const SG::AuxVectorData* ocont = other.container();
 
  if (!ocont || !ocont->hasStore()) {
    AuxElement::clearAuxHelper (container, index);
    return;
  }
 
#ifndef XAOD_STANDALONE
  const SG::auxid_set_t& other_decors = ocont->getDecorIDs();
#endif
  SG::auxid_set_t other_ids = ocont->getAuxIDs();
 
  size_t oindex = other.index();
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  for (SG::auxid_t auxid : other_ids) {
#ifndef XAOD_STANDALONE
    if (other_decors.test (auxid)) {
      // Don't copy decorations --- another thread may be modifying them.
      other_ids.reset (auxid);
      // Warn if we skip a decoration (except for mcEventWeights,
      // for which this is expected).
      if (warnUnlocked && r.getName(auxid) != "mcEventWeights") {
        std::ostringstream ss;
        ss << "skipped unlocked decoration " << r.getName(auxid)
           << " (" << auxid << ")";
        ATHCONTAINERS_WARNING("copyAux", ss.str());
      }
    }
    else
#endif
    if (!r.isLinked (auxid)) {
      r.copy (auxid, container, index, *ocont, oindex, 1);
    }
  }
 
  for (SG::auxid_t auxid : container.getWritableAuxIDs()) {
    if (!other_ids.test (auxid)) {
      r.clear (auxid, container, index, 1);
    }
  }
}
 
 
#ifdef ATHCONTAINERS_R21_COMPAT
void AuxElement::copyAuxHelper (AuxVectorData& container,
                                size_t index,
                                const AuxElement& other,
                                [[maybe_unused]] bool warnUnlocked)
{
  if (!container.hasStore()) return;
  if (!container.hasNonConstStore())
    throw SG::ExcConstAuxData ("copyAux");
 
  const SG::AuxVectorData* ocont = other.container();
 
  if (!ocont || !ocont->hasStore()) {
    AuxElement::clearAuxHelper (container, index);
    return;
  }
 
#ifndef XAOD_STANDALONE
  const SG::auxid_set_t& other_decors = ocont->getDecorIDs();
#endif
  SG::auxid_set_t other_ids = ocont->getAuxIDs();
 
  size_t oindex = other.index();
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  for (SG::auxid_t auxid : other_ids) {
#ifndef XAOD_STANDALONE
    if (other_decors.test (auxid)) {
      // Don't copy decorations --- another thread may be modifying them.
      other_ids.reset (auxid);
      // Warn if we skip a decoration (except for mcEventWeights,
      // for which this is expected).
      if (warnUnlocked && r.getName(auxid) != "mcEventWeights") {
        std::ostringstream ss;
        ss << "skipped unlocked decoration " << r.getName(auxid)
           << " (" << auxid << ")";
        ATHCONTAINERS_WARNING("copyAux", ss.str());
      }
    }
    else
#endif
    if (!r.isLinked (auxid)) {
      r.copy (auxid, container, index, *ocont, oindex, 1);
    }
  }
 
  for (SG::auxid_t auxid : container.getWritableAuxIDs()) {
    if (!other_ids.test (auxid)) {
      r.clear (auxid, container, index, 1);
    }
  }
}
#endif
 
 
} // namespace SG