AuxElement.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#include "AthContainers/AuxElement.h"
#include "AthContainers/AuxStoreStandalone.h"
#include "AthContainers/exceptions.h"
#include "CxxUtils/checker_macros.h"
 
 
 
namespace SG {
 
 
class AuxElementData
  : public AuxVectorData
{
public:
  virtual size_t size_v() const { return 1; }
  virtual size_t capacity_v() const { 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;
}
 
 
//************************************************************************
 
 
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
}
 
 
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)
{
  makePrivateStore();
  if (other)
    this->copyAux (*other);
}
 
 
void AuxElement::clearAux()
{
  if (!m_container) return;
  if (!m_container->hasStore()) return;
  if (!m_container->hasNonConstStore())
    throw SG::ExcConstAuxData ("clearAux", SG::null_auxid);
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  for (SG::auxid_t auxid : m_container->getWritableAuxIDs()) {
    r.clear (auxid, *container(), index(), 1);
  }
}
 
 
void AuxElement::copyAux (const ConstAuxElement& other)
{
  if (!m_container) return;
  if (!m_container->hasStore()) return;
  if (!m_container->hasNonConstStore())
    throw SG::ExcConstAuxData ("copyAux");
 
  const SG::AuxVectorData* ocont = other.container();
 
  if (!ocont || !ocont->hasStore()) {
    this->clearAux();
    return;
  }
 
  size_t oindex = other.index();
  SG::auxid_set_t other_ids = ocont->getAuxIDs();
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  SG::AuxVectorData& cont = *container();
  for (SG::auxid_t auxid : other_ids) {
    if (!r.isLinked (auxid)) {
      r.copy (auxid, cont, index(), *ocont, oindex, 1);
    }
  }
 
  for (SG::auxid_t auxid : m_container->getWritableAuxIDs()) {
    if (!other_ids.test (auxid)) {
      r.clear (auxid, cont, index(), 1);
    }
  }
}
 
 
#ifdef ATHCONTAINERS_R21_COMPAT
 
void AuxElement::copyAux (const AuxElement& other)
{
  if (!m_container) return;
  if (!m_container->hasStore()) return;
  if (!m_container->hasNonConstStore())
    throw SG::ExcConstAuxData ("copyAux");
 
  const SG::AuxVectorData* ocont = other.container();
 
  if (!ocont || !ocont->hasStore()) {
    this->clearAux();
    return;
  }
 
  size_t oindex = other.index();
  SG::auxid_set_t other_ids = ocont->getAuxIDs();
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  AuxVectorData& cont = *container();
  for (SG::auxid_t auxid : other_ids) {
    if (!r.isLinked (auxid)) {
      r.copy (auxid, cont, index(), *ocont, oindex, 1);
    }
  }
 
  for (SG::auxid_t auxid : m_container->getWritableAuxIDs()) {
    if (!other_ids.test (auxid)) {
      r.clear (auxid, cont, index(), 1);
    }
  }
}
#endif
 
 
} // namespace SG