Calorimeter/CaloRec/CaloRec/ToolWithConstantsMixin.icc

-// This file's extension implies that it's C, but it's really -*- C++ -*-.
-
-/*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-/**
- * @file  ToolWithConstantsMixin.icc
- * @author scott snyder <snyder@bnl.gov>
- * @date March, 2006, updated from June, 2004
- * @brief A mixin class to hold a set of constants for an Algorithm,
- *        Tool, or Service.
- */
-
-
-#include "AthenaKernel/errorcheck.h"
-#include "GaudiKernel/AlgTool.h"
-#include "GaudiKernel/Algorithm.h"
-#include "GaudiKernel/Service.h"
-
-
-namespace CaloRec {
-
-
-namespace TWC { // For internal free functions.
-
-
-/**
- * @brief Declare a property to the job options service.
- * @param self The object on which the property is to be defined.
- * @param name The property name.
- * @param c The property value.
- *
- * @c self must be dynamically convertible to an @c Algorithm,
- * @c AlgTool, or @c Service.
- */
-template <class T>
-StatusCode do_declare (ToolWithConstantsMixin* self,
-                       const std::string& name,
-                       T& c)
-{
-  if (AlgTool* x = dynamic_cast<AlgTool*> (self)) {
-    x->declareProperty (name, c);
-    return StatusCode::SUCCESS;
-  } else if (Gaudi::Algorithm* x = dynamic_cast<Gaudi::Algorithm*> (self)) {
-    x->declareProperty (name, c);
-    return StatusCode::SUCCESS;
-  } else if (Service* x = dynamic_cast<Service*> (self)) {
-    x->declareProperty (name, c);
-    return StatusCode::SUCCESS;
-  } else {
-    REPORT_ERROR_WITH_CONTEXT(StatusCode::FAILURE, self->name())
-      << "Not an Algorithm, AlgTool, or Service.";
-    return StatusCode::FAILURE;
-  }
-}
-
-
-} // namespace TWC
-
-
-/**
- * @brief Declare a constant.
- * @param name The name of the constant.
- * @param c Variable to receive the constant value.
- * @param deflt If true, then this constant may be defaulted.
- *
- * This should be called from a tool constructor.
- * The @a c variable will be initialized either from the pool
- * database or from job options, as appropriate.  If the initialization
- * is from job options, it won't happen until after the constructor
- * returns.
- *
- * The @a c variable may be a fundamental numeric type, or it may
- * be an instance of one of the @c Array<N> classes.
- */
-template <class T>
-void
-ToolWithConstantsMixin::declareConstant (const std::string& name,
-                                         T& c,
-                                         bool deflt /*= false*/)
-{
-  c = T();
-  add_constant (makeinfo (name, c, deflt));
-}
-
-
-/**
- * @brief Constructor.
- * @param name The name of the constant.
- * @param c Reference to the constant.
- * @param deflt If true, then this constant may be defaulted.
- */
-template <class T>
-ToolWithConstantsMixin::Propinfo_Val<T>::Propinfo_Val (const std::string& name,
-						       T& c,
-                                                       bool deflt)
-  : Propinfo_Base (name, deflt), m_c(c)
-{
-}
-
-/**
- * @brief Setting a constant (not an Array) from the DB.
- * @param rep The @c Arrayrep for this constant.
- * @param tool The @c ToolWithConstants instance, for error reporting.
- *
- * The database representation of a constant is Arrayrep event if is a
- * single number. We require that the array size is 1 and take the 
- * element [0]. It is cast from const float to the templated type T.
- */
-template <class T>
-StatusCode 
-ToolWithConstantsMixin::Propinfo_Val<T>::setFromDB (const Arrayrep& rep,
-                                                 ToolWithConstantsMixin& tool)
-{
-  // Check that the dimensions match.
-  if (rep.m_data.size()!=1)
-    REPORT_ERROR_WITH_CONTEXT (StatusCode::FAILURE, tool.name())
-      << "Attempt to initialize a number by an array"; 
-  else {
-    // Make the assignment. 
-    // The element in the array is a float (typedef'd)
-    // but T might be any numeric value (e.g. int)
-    m_c = static_cast<T>(rep.m_data[0]);
-  }
-  return StatusCode::SUCCESS;
-}
-
-
-/**
- * @brief Finish up initialization of this constant.
- * @param rep The @c Arrayrep for this constant.
- * @param tool The @c ToolWithConstants instance, for error reporting.
- *
- * This is called from @c setProperty after the property manager
- * has finished its work, and after we've installed the constant
- * in the @c ToolConstants structure.  We get the
- * @c Arrayrep from the @c ToolConstants for this constant.
- *
- * For a simple number, the target will have already been filled
- * in by Gaudi.  However, it turns out that the floating-point
- * parsing done by Gaudi isn't exactly equivalent to that done
- * by C++.  The Array parsing machinery uses the C++ iostream
- * mechanism to do the conversion, and will convert the string
- * `1.525' to the float 1.52499998.  Gaudi, however, uses
- * the Spirit parser, which will convert the same string
- * to the float 1.5250001.  So, reset the target here
- * for consistency.
- */
-template <class T>
-StatusCode
-ToolWithConstantsMixin::Propinfo_Val<T>::set (const Arrayrep& rep,
-                                              ToolWithConstantsMixin& /*tool*/)
-{
-  CxxUtils::Array<0> arr (rep);
-  m_c = arr;
-  return StatusCode::SUCCESS;
-}
-
-
-/**
- * @brief Constructor.
- * @param name The name of the constant.
- * @param c Reference to the constant.
- * @param deflt If true, then this constant may be defaulted.
- */
-template <unsigned int N>
-ToolWithConstantsMixin::Propinfo_Array<N>::Propinfo_Array (
-  const std::string& name,
-  Array<N>& c,
-  bool deflt)
-  : Propinfo_Base (name, deflt), m_c (c)
-{
-}
-
-
-/**
- * @brief Finish up initialization of this constant.
- * @param rep The @c Arrayrep for this constant.
- * @param tool The @c ToolWithConstants instance, for error reporting.
- *
- * This is called from @c setProperty after the property manager
- * has finished its work, and after we've installed the constant
- * in the @c ToolConstants structure.  We get the
- * @c Arrayrep from the @c ToolConstants for this constant.
- *
- * For an @c Array<N>, we need to initialize the actual @c Array<N>
- * instance from the @c Arrayrep we've gotten from the
- * @c ToolConstants structure.
- */
-template <unsigned int N>
-StatusCode
-ToolWithConstantsMixin::Propinfo_Array<N>::set (const Arrayrep& rep,
-                                                ToolWithConstantsMixin& tool)
-{
-  // Check that the dimensions match.
-  if (rep.m_shape.size() != N) {
-    REPORT_ERROR_WITH_CONTEXT (StatusCode::FAILURE, tool.name())
-      << "Dimensionality from job options (" << rep.m_shape.size()
-      << ") doesn't match declared dimensionality (" << N
-      << ") for constant " << m_name;
-    return StatusCode::FAILURE;
-  }
-
-  // Make the assignment.
-  m_c = CaloRec::Array<N> (rep);
-  return StatusCode::SUCCESS;
-}
-
-
-/**
- * @brief Setting an Array-constant from the DB.
- * @param rep The @c Arrayrep for this constant.
- * @param tool The @c ToolWithConstants instance, for error reporting.
- *
- * For arrays, we can simply call the normal set function
- */
-template <unsigned int N>
-StatusCode
-ToolWithConstantsMixin::Propinfo_Array<N>::setFromDB (const Arrayrep& rep,
-                                                  ToolWithConstantsMixin& tool)
-{
-  return set(rep, tool);
-} 
-
-
-/**
- * @brief Construct a new @c Propinfo_* instance for @a c.
- * @param name The name of the constant being declared.
- * @param c The constant being declared.
- * @param deflt If true, then this constant may be defaulted.
- * @return A new instance of a class deriving from @c Propinfo_Base.
- *
- * This family of overloaded functions creates a new instance
- * of a class deriving from @c Propinfo_Base that is appropriate
- * for the type of the constant @c.
- *
- * This one makes a @c Propinfo_Val<T> instance,
- * appropriate for numeric types, and declares it to the property service.
- */
-template <class T>
-ToolWithConstantsMixin::Propinfo_Base*
-ToolWithConstantsMixin::makeinfo (const std::string& name, T& c, bool deflt)
-{
-  Propinfo_Val<T>* pi = new Propinfo_Val<T> (name, c, deflt);
-  StatusCode sc = TWC::do_declare (this, name, c);
-  if (sc.isFailure()) {
-    REPORT_ERROR (sc) << "Error from property service when declaring " << name;
-    delete pi;
-    return 0;
-  }
-  return pi;
-}
-
-
-/**
- * @brief Construct a new @c Propinfo_* instance for @a c.
- * @param name The name of the constant being declared.
- * @param c The constant being declared.
- * @param deflt If true, then this constant may be defaulted.
- * @return A new instance of a class deriving from @c Propinfo_Base.
- *
- * This family of overloaded functions creates a new instance
- * of a class deriving from @c Propinfo_Base that is appropriate
- * for the type of the constant @c.
- *
- * This one makes a @c Propinfo_Array<N> instance,
- * appropriate for multidimensional array types, and declares
- * it to the property service.
- */
-template <unsigned int N>
-ToolWithConstantsMixin::Propinfo_Base*
-ToolWithConstantsMixin::makeinfo (const std::string& name,
-                                  Array<N>& c,
-                                  bool deflt)
-{
-  Propinfo_Array<N>* pi =  new Propinfo_Array<N> (name, c, deflt);
-
-  // The property service doesn't know about @c Array<N>, so we can't
-  // declare it directly.  Instead, we give it a string buffer; we'll
-  // do the conversion later.
-  StatusCode sc = TWC::do_declare (this, name, pi->m_buf);
-  if (sc.isFailure()) {
-    REPORT_ERROR (sc) << "Error from property service when declaring " << name;
-    delete pi;
-    return 0;
-  }
-
-  // We can get rid of the property string at this point.
-  // These can potentially be very large!
-  pi->m_buf.clear();
-  return pi;
-}
-
-
-} // namespace CaloRec

Calorimeter/CaloRec/src/CaloClusterCorrDBWriter.cxx

@@ -11,7 +11,6 @@
 #include "CaloClusterCorrDBWriter.h"
 #include "GaudiKernel/ThreadLocalContext.h"
 
-#include "CaloRec/ToolWithConstantsMixin.h"
 #include "CaloConditions/ToolConstants.h"
 #include "AthenaKernel/errorcheck.h"
 

Calorimeter/CaloRec/src/ToolWithConstantsMixin.cxx

-// This file's extension implies that it's C, but it's really -*- C++ -*-.
-
-/*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-/**
- * @file  ToolWithConstantsMixin.cxx
- * @author scott snyder <snyder@bnl.gov>
- * @date March, 2006, updated from June, 2004
- * @brief A mixin class to hold a set of constants for an Algorithm,
- *        Tool, or Service.
- */
-
-
-#include "CaloRec/ToolWithConstantsMixin.h"
-#include "AthenaKernel/errorcheck.h"
-#include "GaudiKernel/Bootstrap.h"
-#include "GaudiKernel/IService.h"
-#include "GaudiKernel/ISvcLocator.h"
-#include "GaudiKernel/AlgTool.h"
-#include "GaudiKernel/Algorithm.h"
-#include "GaudiKernel/Service.h"
-#include "AthenaKernel/getMessageSvc.h"
-
-#include "CoralBase/AttributeListException.h"
-#include "CoralBase/Blob.h"
-//#include "CoolKernel/StorageType.h"
-
-#include "CaloRec/Blob2ToolConstants.h"
-#include <stdexcept>
-
-
-namespace CaloRec {
-
-
-/**
- * @brief Constructor.
- *
- * The only reason we need this is that SG stupidly requires that the
- * DataHandle be const.
- */
-ToolWithConstantsMixin::ToolWithConstantsMixin()
-  : m_detStore(nullptr),
-    m_use_callback(true),
-    m_order(0),
-    m_isdummy(false),
-    m_coolInlineTool (nullptr),
-    m_toolSvc (nullptr)
-{
-}
-
-
-/**
- * @brief Remainder of constructor code, that needs the complete
- *        class to be initialized.
- * @param toolcls Name of derived C++ class.
- *                This is used only for @c mergeConstants; further,
- *                it can be safely defaulted for the @c AlgTool case.
- *
- * This needs to be called from the derived class's constructor.
- */
-void
-ToolWithConstantsMixin::finish_ctor (const std::string& toolcls /*= ""*/)
-{
-  m_use_callback = true;
-  m_toolcls = toolcls;
-
-  if (AlgTool* thistool = dynamic_cast<AlgTool*> (this)) {
-    thistool->declareProperty ("detStoreKey", m_detStoreKey);
-    thistool->declareProperty ("prefix",      m_prefix);
-    thistool->declareProperty ("useCallback", m_use_callback);
-    thistool->declareProperty ("COOLFolder",  m_folderName);
-    if (m_toolcls.empty())
-      m_toolcls = thistool->type();
-  }
-  else if (Gaudi::Algorithm* thisalg = dynamic_cast<Gaudi::Algorithm*> (this)) {
-    thisalg->declareProperty ("detStoreKey", m_detStoreKey);
-    thisalg->declareProperty ("prefix",      m_prefix);
-    thisalg->declareProperty ("useCallback", m_use_callback);
-    thisalg->declareProperty ("COOLFolder",  m_folderName);
-  }
-  else if (Service* thissvc = dynamic_cast<Service*> (this)) {
-    thissvc->declareProperty ("detStoreKey", m_detStoreKey);
-    thissvc->declareProperty ("prefix",      m_prefix);
-    thissvc->declareProperty ("useCallback", m_use_callback);
-    thissvc->declareProperty ("COOLFolder",  m_folderName);
-  }
-  else
-    std::abort();
-
-  declareConstant ("order",       m_order = 0,        true);
-  declareConstant ("isDummy",     m_isdummy = false,  true);
-}
-
-
-/**
- * @brief Destructor.
- */
-ToolWithConstantsMixin::~ToolWithConstantsMixin()
-{
-  // Delete the Propinfo_* structures that we've allocated.
-  for (unsigned int i=0; i < m_infos.size(); i++)
-    delete m_infos[i];
-}
-
-
-/**
- * @brief Initialize method.
- *
- * Here, we check that all declared constants actually received values.
- *
- * The class using this must override @c initialize and call first
- * the standard @c AlgTool::initialize followed by
- * @c ToolWithConstantsMixin::initialize.
- */
-StatusCode ToolWithConstantsMixin::initialize()
-{  
-  ISvcLocator* svcLoc = Gaudi::svcLocator( );
-  if (!svcLoc) {
-    REPORT_MESSAGE(MSG::ERROR) << "Could not get svcLocator!";
-    return StatusCode::FAILURE;
-  }
-
-  CHECK(svcLoc->service("ToolSvc",m_toolSvc));
-  CHECK(svcLoc->service("DetectorStore", m_detStore));
-
-  REPORT_MESSAGE(MSG::DEBUG) << "Source of constants: DetStoreKey: '" << m_detStoreKey << "' FolderName: '" << m_folderName << "'";
-
-  // The SG key should be set via job options.
-  // Don't try to read from pool if there isn't one set.
-  StatusCode sc = StatusCode::SUCCESS;
-  
-    
-  if (!m_detStoreKey.empty() && !m_folderName.empty() && m_detStore->contains<CondAttrListCollection>(m_folderName)) {
-    //First case: Read constants from COOL inline
-    REPORT_MESSAGE(MSG::DEBUG) << "Reading constants from COOL-inline storage. Folder " << m_folderName 
-			       << " channel " << m_detStoreKey;
-
-    // ...register callback.
-    if (m_use_callback) {
-      CHECK(m_toolSvc->retrieveTool("Blob2ToolConstants",m_coolInlineTool));
-      CHECK(m_coolInlineTool->addFolder(m_folderName,m_detStoreKey));
-      CHECK(m_detStore->regFcn(&Blob2ToolConstants::fillObjects,
-			       m_coolInlineTool,
-			       &CaloRec::ToolWithConstantsMixin::processConstantsFromDB,
-			       dynamic_cast<CaloRec::ToolWithConstantsMixin*>(this),
-			       true));
-    }
-    else {
-      CHECK (m_detStore->bind (m_DBconstants,m_detStoreKey));
-      int i=0;
-      std::list<std::string> l;
-      CHECK(processConstantsFromDB (i, l) );
-    }
-  }
-  else if (!m_detStoreKey.empty() && m_detStore->contains<ToolConstants>(m_detStoreKey)) {
-     REPORT_MESSAGE(MSG::DEBUG) << "Reading constants from POOL storage. SG Key " << m_detStoreKey;
-    //Second case: Read from POOL (relayed via COOL or CondProxyProviderSvc) 
-     // ...register callback.
-     if (m_use_callback) {
-       CHECK(m_detStore->regFcn(
-				&CaloRec::ToolWithConstantsMixin::processConstantsFromDB,
-				dynamic_cast<CaloRec::ToolWithConstantsMixin*>(this),
-				m_DBconstants,m_detStoreKey));
-     }
-     else {
-       CHECK (m_detStore->bind (m_DBconstants, m_detStoreKey));
-       int i=0;
-       std::list<std::string> l;
-       CHECK( processConstantsFromDB (i, l) );
-     }
-  }
-  else {
-    REPORT_MESSAGE(MSG::INFO) << "No database info found. Loading all from jobOpts";
-    // Check to be sure that all constants have been initialized.
-    if (!m_isdummy) {
-      for (unsigned int i=0; i < m_infos.size(); i++) {
-        if (!m_infos[i]->m_set && !m_infos[i]->m_default) {
-          REPORT_ERROR(StatusCode::FAILURE)
-            << "Constant named " << m_infos[i]->m_name
-            << " did not get initialized. ";
-          sc = StatusCode::FAILURE;
-        }
-      }
-      if (sc.isFailure())
-        REPORT_ERROR(StatusCode::FAILURE)
-          << "One or more constants were not set by jobO "
-          << "and could not be loaded from the DetStore!";  
-    }
-  }
-  return sc;
-}   
-
-     
-/**
- * @brief IOVDB callback function
- * @param Macro defined in AthenaKernel/IOVSvcDefs.h
- *
- * This function is called when ToolConstants are loaded from pool.
- * It checks which constants have been already set by the PropertySvc,
- * other constants are set by this function. 
- */
-StatusCode
-ToolWithConstantsMixin::processConstantsFromDB (IOVSVC_CALLBACK_ARGS_K(keys))
-{
-  MsgStream log(Athena::getMessageSvc(), name());
-  log << MSG::DEBUG
-      << "In Callback function ToolWithConstants::processConstantsFromDB" 
-      << endmsg;
-
-  if (!m_folderName.empty()) {
-    //COOL-inline case
-    if (std::find(keys.begin(),keys.end(),m_folderName)==keys.end()) {
-       log << MSG::DEBUG
-	   << "The cool folder we care about (" << m_folderName<< ") is not in the list of keys. Do nothing." << endmsg;
-       return StatusCode::SUCCESS;
-    }
-    else
-       log << MSG::DEBUG
-	   << "Found cool folder " << m_folderName << " in the list of keys." << endmsg;
-  }
-
-  // Check validity
-  //if (!m_DBconstants.isValid()) {
-  if (m_detStore->retrieve(m_DBconstants, m_detStoreKey).isFailure()) {
-    log << MSG::ERROR << "DataHandle of ToolConstants object invalid!"
-        << endmsg;
-    return StatusCode::FAILURE;
-  }
-  
-  return fillFromDB(m_DBconstants);
-}
-
-StatusCode
-ToolWithConstantsMixin::fillFromDB(const ToolConstants* constants) {
-  MsgStream log(Athena::getMessageSvc(), name());
-  // Check what's already set and what's missing
-  for (unsigned int i=0;i<m_infos.size();i++) {
-    if (m_infos[i]->m_set) {
-      log << MSG::DEBUG << "Property '" << m_infos[i]->m_name
-          << "' set by jobOptions." << endmsg;
-    } 
-    else if (constants->hasrep (m_prefix + m_infos[i]->m_name)) {
-      try {
-        const Arrayrep& rep =
-          constants->getrep(name(),               //context (tool name)
-			    m_prefix + m_infos[i]->m_name); // Prop name 
-
-        // remember that this constant is set.
-        m_infos[i]->m_setDB = true;
-        CHECK(m_infos[i]->setFromDB(rep, *this));
-
-        if (m_infos[i]->m_setDB)
-          log << MSG::DEBUG << "Property '" << m_infos[i]->m_name
-              << "' updated from database." << endmsg;
-        else
-          log << MSG::DEBUG << "Property '" << m_infos[i]->m_name
-              << "' loaded from database."<< endmsg;
-      }
-      catch (GaudiException& e)
-      {
-      }
-    } // end else
-  } // end for           
-
-  // Now check if all constants were set (either be jobO or DB)
-  StatusCode sc = StatusCode::SUCCESS;
-  if (!m_isdummy) {
-    for (unsigned int i=0; i < m_infos.size(); i++) {
-      if (!m_infos[i]->m_set && !m_infos[i]->m_setDB && !m_infos[i]->m_default)
-      {
-        REPORT_ERROR(StatusCode::FAILURE)
-          << "Constant named " << m_infos[i]->m_name
-          << " did not get initialized from jobOptions "
-          << "and could not be loaded from DB.";
-        sc = StatusCode::FAILURE;
-      }
-    }
-
-    // Check version.
-    if (constants->version() > version()) {
-      REPORT_ERROR(StatusCode::FAILURE)
-        << "Constants for tool " << name() << " require code version "
-        << m_DBconstants->version() << " but only version "
-        << version() << " is available.";
-      sc = StatusCode::FAILURE;
-    }
-  }
-
-  return sc;
-}         
-
-
-/**
- * @brief Method to set a property value.
- * @param propname The name of the property to set.
- * @param value The value to which to set it.
- * @return Gaudi status code.
- *
- * The property service calls this method when it actually makes a property
- * setting.  We override it in order to hook our own code into the process.
- * If this property corresponds to one of our declared
- * constants, we install it in the @c ToolConstants structure.
- * If needed, we also complete initialization of the declared
- * variable here.
- *
- * The class using this must override this method, and call first
- * @c AlgTool::setProperty
- * followed by @c ToolWithConstantsMixin::setProperty.
- * You may need to use a using directive to prevent warnings
- * (like above, but using the other base class).
- *
- * This version is used by Gaudi up to at least v16.
- */
-StatusCode
-ToolWithConstantsMixin::setProperty (const std::string& propname,
-                                     const std::string& value)
-{
-  // Don't do anything if this was defaulted.
-  // We'll either read it from pool later or give an error.
-  if (value.empty() || value == "\"\"")
-    return StatusCode::SUCCESS;
-
-  // Loop through the declared constants, and see if there's one that
-  // matches the input name.  It's ok if there's no match.
-  for (unsigned int i=0; i < m_infos.size(); i++) {
-    if (m_infos[i]->m_name == propname) {
-      // Found a match.  Remember that we've seen this.
-      m_infos[i]->m_set = true;
-
-      // Install this name in the @c ToolConstants structure.
-      try {
-        const Arrayrep& rep = m_constants.newrep (name(),
-                                                  propname,
-                                                  value);
-
-        // Complete any other (type-dependent) needed initialization.
-        CHECK( m_infos[i]->set (rep, *this) );
-      }
-      catch (const std::runtime_error& e) {
-        REPORT_MESSAGE (MSG::ERROR) << "Error reading from job options: "
-                                    << e.what();
-        return StatusCode::FAILURE;
-      }
-        
-      break;
-    }
-  }
-
-  // Done.
-  return StatusCode::SUCCESS;
-}
-
-
-/**
- * @brief Method to set a property value.
- * @param p The property name/value to set.
- * @return Gaudi status code.
- *
- * The property service calls this method when it actually makes a property
- * setting.  We override it in order to hook our own code into the process.
- * If this property corresponds to one of our declared
- * constants, we install it in the @c ToolConstants structure.
- * If needed, we also complete initialization of the declared
- * variable here.
- *
- * The class using this must override this method, and call first
- * @c AlgTool::setProperty
- * followed by @c ToolWithConstantsMixin::setProperty.
- * You may need to use a using directive to prevent warnings
- * (like above, but using the other base class).
- *
- * This version is used by Gaudi as of v19.
- */
-StatusCode
-ToolWithConstantsMixin::setProperty (const Gaudi::Details::PropertyBase& p)
-{
-  return CaloRec::ToolWithConstantsMixin::setProperty (p.name(), p.toString());
-}
-
-
-
-/**
- * @brief Add a new constant to our store.
- * @param pi The @c Propinfo instance describing this constant.
- */
-void ToolWithConstantsMixin::add_constant (Propinfo_Base* pi)
-{
-  if (!pi)
-    return;
-
-  // Make sure that a name isn't duplicated.
-  for (unsigned int i=0; i < m_infos.size(); i++)
-    if (m_infos[i]->m_name == pi->m_name) {
-      REPORT_ERROR(StatusCode::FAILURE)
-        << "Duplicate constant: " << pi->m_name;
-      delete pi;
-      return;
-    }
-
-  // Record this declaration in @c m_infos.
-  // @c makeinfo is one of an overloaded family of functions that
-  // creates the @c Propinfo_* structure for the type of @a c.
-  m_infos.push_back (pi);
-}
-
-
-/**
- * @brief Constructor.
- * @param name The name of the constant.
- */
-ToolWithConstantsMixin::Propinfo_Base::Propinfo_Base (const std::string& name,
-                                                      bool deflt)
-  : m_name (name),
-    m_set (false),
-    m_setDB (false),
-    m_default (deflt)
-{
-}
-
-
-/**
- * @brief Destructor.
- *
- * Just so that this class gets a vtable.
- */
-ToolWithConstantsMixin::Propinfo_Base::~Propinfo_Base ()
-{
-}
-
-
-/**
- * @brief Finish up initialization of this constant.
- * @param rep The @c Arrayrep for this constant.
- * @param tool The @c ToolWithConstants instance, for error reporting.
- *
- * This is called from @c setProperty after the property manager
- * has finished its work, and after we've installed the constant
- * in the @c ToolConstants structure.  We get the
- * @c Arrayrep from the @c ToolConstants for this constant.
- *
- * The action needed here depends on the constant type.
- * This default implementation doesn't do anything.
- */
-StatusCode
-ToolWithConstantsMixin::Propinfo_Base::set (const Arrayrep& /*rep*/,
-                                            ToolWithConstantsMixin& /*tool*/)
-{
-  return StatusCode::SUCCESS;
-}
-
-
-/**
- * @brief Set a constant from the Database.
- * @param rep The @c Arrayrep for this constant.
- * @param tool The @c ToolWithConstants instance, for error reporting.
- *
- * Called explicitly by the callback function.
- *
- * The action needed here depends on the constant type.
- * This default implementation doesn't do anything.
- */
-StatusCode
-ToolWithConstantsMixin::Propinfo_Base::setFromDB (const Arrayrep& /*rep*/,
-						  ToolWithConstantsMixin& /*tool*/)
-{
-  return StatusCode::SUCCESS;
-}
-
-
-/**
- * @brief Merge our constants into @c out with the proper prefix.
- * @param[out] out Object to receive our constants.
- */
-StatusCode
-ToolWithConstantsMixin::mergeConstants (ToolConstants& out) const
-{
-  if (out.clsname().empty()) {
-    out.clsname (m_toolcls);
-    out.version (version());
-  }
-  else if (out.clsname() != m_toolcls) {
-    REPORT_ERROR(StatusCode::FAILURE)
-      << "Trying to write to ToolConstants for tools of differing types: "
-      << out.clsname() << " and " << m_toolcls;
-    return StatusCode::FAILURE;
-  }
-  else if (out.version() != version()) {
-    REPORT_ERROR(StatusCode::FAILURE)
-      << "Trying to write to ToolConstants for differing versions of tool "
-      << out.clsname() << ": " << out.version() << " and " << version();
-    return StatusCode::FAILURE;
-  }
-
-  for (unsigned int i=0; i < m_infos.size(); i++) {
-    // Decide which source block to use.
-    const ToolConstants& source = (m_infos[i]->m_setDB ?
-                                   *m_DBconstants :
-                                   m_constants);
-    if (!m_isdummy || m_infos[i]->m_name == "isDummy")
-      out.setrep (m_prefix + m_infos[i]->m_name,
-                  source.getrep (name(), m_infos[i]->m_name));
-  }
-  return StatusCode::SUCCESS;
-}
-
-
-/**
- * @brief Return the version number for this tool.
- *
- * A saved set of constants includes both the C++ class name and
- * a version number.  The idea is that the version number can
- * be bumped whenever there's a backwards-incompatible change;
- * this gives some protection against trying to use an old version
- * of a tool with an incompatible newer set of constants.
- *
- * If you want a tool to have a version number, override this method.
- * Otherwise, it will default to a version number of 0.
- */
-int ToolWithConstantsMixin::version() const
-{
-  return 0;
-}
-
-
-void ToolWithConstantsMixin::writeConstants(std::ostream& stream, const std::string& name) const {
-  stream << "Member: m_constants" << std::endl;
-  m_constants.writeConstants(stream,name);
-  if (m_DBconstants) {
-    stream << "Member: m_DBconstants" << std::endl;
-    m_DBconstants->writeConstants(stream,name);
-  }
-  //stream << "Member m_COOLconstants" << std::endl;
-  //m_COOLconstants->writeConstants(stream,name);
-  return;
-}
-
-} // namespace CaloRec
-

Calorimeter/CaloTools/python/CaloNoiseCondAlg.py

-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 
 from AthenaCommon.AlgSequence import AthSequencer
 from IOVDbSvc.CondDB import conddb
@@ -17,9 +17,11 @@ def CaloNoiseCondAlg(noisetype="totalNoise"):
         return getattr(condSeq,noiseAlgName)
  
     if (conddb.isMC):
-        condSeq += _CaloNoiseCondAlgMC(noiseAlgName,noisetype)
+        alg = _CaloNoiseCondAlgMC(noiseAlgName,noisetype)
     else: 
-        condSeq += _CaloNoiseCondAlgData(noiseAlgName,noisetype)
+        alg = _CaloNoiseCondAlgData(noiseAlgName,noisetype)
+    condSeq += alg
+    return alg
 
 
 def _CaloNoiseCondAlgMC(noiseAlgName,noisetype):

Control/AthenaCommon/python/Configurable.py

@@ -124,10 +124,6 @@ class Configurable( six.with_metaclass (ConfigurableMeta.ConfigurableMeta, objec
                try:
                   setattr( conf, n, v )
                except AttributeError as originalAttributeError:
-                # rather annoying that we have to be somewhat silent here (the
-                # most common cases are 'name' and user kw args to be supplied
-                # to an overridden __init__)
-                  log.debug( 'not accepting keyword "%s" as a property', n )
 
                 # now for a completely different can of worms ...
                   acceptableKeyWord = False
@@ -149,7 +145,6 @@ class Configurable( six.with_metaclass (ConfigurableMeta.ConfigurableMeta, objec
                       # times, but we shouldn't be in this loop too often anyway
                         confinit = getattr( confklass, '__init__' )
                         if n in six.get_function_code(confinit).co_varnames:
-                           log.debug( 'accepting keyword "%s" as an argument for %s.__init__', n, confklass.__name__ )
                            acceptableKeyWord = True
                            break
                      except AttributeError:

Control/AthenaMPTools/src/SharedHiveEvtQueueConsumer.cxx

@@ -738,7 +738,7 @@ SharedHiveEvtQueueConsumer::initHive() {
       return StatusCode::FAILURE;
     }
 
-    m_schedulerSvc = serviceLocator()->service("ForwardSchedulerSvc");
+    m_schedulerSvc = serviceLocator()->service("AvalancheSchedulerSvc");
 
   // m_whiteboard = serviceLocator()->service(m_whiteboardName);
   // if( !m_whiteboard.isValid() )  {

Control/AthenaMonitoring/share/DQMonFlagsConfig_jobOptions.py

@@ -66,6 +66,7 @@ else:
    local_logger.warning("invalid DQMonFlags.monType: %s, using default monManEnvironment", DQMonFlags.monType())
 
 # the meaning of this flag has changed in MT
+from TriggerJobOpts.TriggerFlags import TriggerFlags
 if (rec.doTrigger() == False and 
     not (TriggerFlags.doMT() and DQMonFlags.monManEnvironment=='tier0ESD' and DQMonFlags.useTrigger())):
    DQMonFlags.useTrigger=False     # steers trigger-awareness

Control/CxxUtils/CMakeLists.txt

@@ -102,6 +102,12 @@ atlas_add_test( exctrace2_test
    LINK_LIBRARIES CxxUtils
    LOG_IGNORE_PATTERN "no version information available" )
 
+atlas_add_test(
+   OptionalContainer_test
+   SOURCES test/OptionalContainer_test.cxx
+   LINK_LIBRARIES CxxUtils
+)
+
 # Set up the "simple" tests:
 foreach( test sincos_test ArrayScanner_test Arrayrep_test
       Array_test PackedArray_test pointer_list_test FloatPacker_test

Control/CxxUtils/CxxUtils/OptionalContainer.h

+/*
+ * Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+ * @file CxxUtils/OptionalContainer.h
+ * @author Stephen Nicholas Swatman <stephen.nicholas.swatman@cern.ch>
+ * @date September 2020
+ * @brief A container of optional values, with ergonomic methods.
+ */
+
+#ifndef CXXUTILS_OPTIONALCONTAINER_H
+#define CXXUTILS_OPTIONALCONTAINER_H
+
+#include <optional>
+#include <array>
+#include <vector>
+
+namespace {
+    /**
+     * @brief Helper struct to allow us to partially apply the size parameter
+     * to std::array.
+     *
+     * This class allows us to partially apply the std::array templated class
+     * with only the size argument, allowing us to apply the contained type
+     * typename later, completing the type.
+     *
+     * If this seems like an odd idea, it may be useful to approach the problem
+     * from a type theoretical view, and abstract away from the cold hard C++
+     * for just a moment. Specifically, we need to realize that std::array
+     * (without the template parameters applied) is essentially a binary
+     * function _at the type level_ (called a type constructor); it takes an
+     * argument of kind (which is what we call "types" in the typed lambda
+     * calculus one level above the base) typename, and a size_t, and returns
+     * a concrete type. In C++ like syntax, it's a function at the type level
+     * with the following signature:
+     *
+     * typename std::array(typename T, size_t N);
+     *
+     * If you're more familiar with a functional syntax like Haskell's, then
+     * firstly I weep for you because trying to do any type-level computation
+     * in C++ is a pain, but you may also find the following syntax more easy
+     * to read (assuming DataKinds):
+     *
+     * std::array :: * -> Integer -> *
+     *
+     * Standard C++ syntax allows us to only fully apply these types, we can't
+     * apply them partially (just like how we cannot partially apply normal
+     * functions). In other words, we cannot pass std::array a contained type
+     * only, capturing that typename in a way reminiscent of a closure, giving
+     * us a partially applied type constructor with signature:
+     *
+     * template <typename> typename std::array'(size_t N);
+     * std::array :: Integer -> *
+     *
+     * And we certainly cannot partially apply in the reverse order, passing it
+     * a size_t for the array size and then passing it the container type to
+     * get a partially applied type constructor:
+     *
+     * template <size_t> typename std::array''(typename T);
+     * std::array :: * -> *
+     *
+     * However, this is something we would very much like to do. Indeed, we
+     * want our optional container to be relatively type-agnostic, and for that
+     * to be possible the type of our OptionalBase has to be (where C is our
+     * underlying container type):
+     *
+     * typname OptionalBase(typename (*C)(typename), ...);
+     * OptionalBase :: (* -> *) -> ... -> *
+     *
+     * So, for example, we could pass the std::vector type constructor as a
+     * template parameter of OptionalBase directly, because it has a single
+     * argument of kind typename. However, std::array does not do this by
+     * default, since it has two arguments. We need to partially apply the size
+     * argument before we can pass it to OptionalBase in a way that is similar
+     * to the way we would pass std::vector.
+     *
+     * Wrapping std::array in a templated class with a templated alias allows
+     * us this. Indeed, PartiallyAppliedArray has the type:
+     *
+     * typename PartiallyAppliedArray(size_t);
+     *
+     * So, for example, we can construct the type PartiallyAppliedArray<10> to
+     * get a struct wrapping std::array with the size parameter partially
+     * applied with the value 10. This type then contains a type alias, type,
+     * or PartiallyAppliedArray<10>::type which is a unary type constructor
+     * with a single argument, which is exactly what we want. So, we can now
+     * pass this type directly to OptionalBase, or we can construct an array of
+     * 10 integers from it by writing PartiallyAppliedArray<10>::type<int>.
+     *
+     * @tparam N the size of the array.
+     */
+    template<std::size_t N>
+    struct PartiallyAppliedArray {
+        template<typename T>
+        using type = std::array<T, N>;
+    };
+
+    /**
+     * @brief Helper struct to give compile-time info about static castability.
+     *
+     * In our following definitions, we want to know whether a type A is
+     * castable to a type B. For this, we need to use some helper structs which
+     * we can use in static assertsions. This is relatively standard procedure
+     * for C++ template metaprogramming, and recipes and explanations of this
+     * kind of code can be found all across the internet.
+     *
+     * This first type is the default case, were F turns out to not be
+     * statically castable to T. It subclasses the false type, so ::value will
+     * return false.
+     */
+    template <class F, class T, class=T>
+    struct is_static_castable : std::false_type
+    {};
+
+    /**
+     * This is the specialized sibling of the type above, in which F can indeed
+     * be converted to T. It subclasses the true type, so ::value will return
+     * true.
+     */
+    template <class F, class T>
+    struct is_static_castable<F, T, decltype(static_cast<T>(std::declval<F>()))> : std::true_type
+    {};
+}
+
+namespace CxxUtils {
+    /**
+     * @brief The base class representing a container filled with optional
+     * values.
+     *
+     * This is the meat of the pudding of our optional container types. It
+     * allows us to check whether values are set, set them, unset them, and a
+     * few more things.
+     *
+     * @tparam C the underlying container type, must take a single typename
+     * argument representing the contained type.
+     * @tparam I the index type, which will usually be size_t but can also be
+     * any value which is convertible to size_t, or other types if the
+     * container is map-like.
+     * @tparam V the contained type, without the optional type constructor
+     * applied to it.
+     *
+     * As an example, OptionalBase<std::vector, MyEnum, std::string> is an
+     * optional container backed by a vector, indexed by an enumeration type,
+     * containing optional strings.
+     *
+     * Of course, I could be derived easily from C<std::optional<V>>::size_type
+     * but the approach of having a separately and explicitly defined template
+     * variable for this is more powerful, since it also allows us to index
+     * with, for example, enumeration types in a type-safe fashion.
+     */
+    template<template <typename> typename C, typename I, typename V>
+    class OptionalBase {
+    public:
+        /**
+         * F is the inner type, which is the type constructor of the underlying
+         * container type C applied to the std::optional type constructor,
+         * applied in turn to the value type V.
+         */
+        using F = C<std::optional<V>>;
+
+        static_assert(
+            is_static_castable<I, typename F::size_type>::value,
+            "Index type must be castable to storage class index type!"
+        );
+
+        /**
+         * @brief Check whether the specified index is set.
+         *
+         * This method is used to determine whether a value in the array is set
+         * or unset.
+         *
+         * @param i the index to check.
+         * @return true if the value at i is set, false otherwise.
+         */
+        bool is_set(const I & i) const;
+
+        /**
+         * @brief Update an index that is already set.
+         *
+         * This method updates the value at a given index, but only if that
+         * value is already set. If it is unset, this method is a noop.
+         *
+         * @param i the index to update.
+         * @param v the value to be set.
+         * @tparam W the value type, should be convertible to V.
+         * @return true if the update succeeds, otherwise false.
+         *
+         * @note The fact that this method is templated with a seemingly
+         * useless template variable W might be confusing, but it has to do
+         * with a concept that is colloquially known as universal references,
+         * where a single function can accept both lvalue references and rvalue
+         * references in an efficient way. This relies on templating, and
+         * requires a separate function level template separate from the class
+         * level template variable V.
+         */
+        template<typename W>
+        bool update(const I & i, W && v);
+
+        /**
+         * @brief Set an index that is not already set.
+         *
+         * This method sets the value at a given index, but only if that value
+         * is not already set. If the value is set, this method is a noop.
+         *
+         * @param i the index to set.
+         * @param v the value to be set.
+         * @tparam W the value type, should be convertible to V.
+         * @return true if the set succeeds, otherwise false.
+         *
+         * @note See the comment on update() for more info about W.
+         */
+        template<typename W>
+        bool set_if_unset(const I & i, W && v);
+
+        /**
+         * @brief Update the value of a key, regardless of existing value.
+         *
+         * This method inserts a new value at a given index, regardless of
+         * whether a value already exists at that location. This operation
+         * always succeeds.
+         *
+         * @param i the index to set.
+         * @param v the value to be set.
+         * @tparam W the value type, should be convertible to V.
+         * @return true, always.
+         *
+         * @note The return value of this method is superfluous, but it's there
+         * to preserve the symmetry with the update and set methods.
+         * @note See the comment on update() for more info about W.
+         */
+        template<typename W>
+        bool set(const I & i, W && v);
+
+        /**
+         * @brief Unset the value at a given key.
+         *
+         * This method removes the value at a given index, and sets the value
+         * to undefined. This also deletes the old value. This operation always
+         * succeeds.
+         *
+         * @param i the index to unset.
+         */
+        void unset(const I & i);
+
+        /**
+         * @brief Increment the value at a given index by one.
+         *
+         * This method increases the value of a given key by one. For this
+         * method to exist, the underlying type T must be incrementable. As of
+         * C++20, this can be represented using the std::incrementable
+         * constraint, but not yet.
+         *
+         * @param i the index to increment.
+         */
+        void increment(const I & i);
+
+        /**
+         * @brief Get the value at a given key (const).
+         *
+         * Getter for the value at a given location. Returns an optional
+         * reference, since we cannot guarantee that the object exists.
+         *
+         * @param i the index to retrieve.
+         * @return a reference to the optional value held at the index.
+         */
+        const std::optional<V> & get(const I & i) const;
+
+        /**
+         * @brief Get the value at a given key.
+         *
+         * Same as get(), but not const.
+         *
+         * @param i the index to retrieve.
+         * @return a reference to the optional value held at the index.
+         */
+        std::optional<V> & get(const I & i);
+
+        /**
+         * @brief Coalesce a single value in the array, giving priority to the
+         * left hand side.
+         *
+         * Updates a field in the array, giving priority to the left hand side.
+         * The workings of this methods are concisely described by the
+         * following case analysis:
+         *
+         * v << w = case (v, w) of:
+         *     Just u, _ = Just u
+         *     _,      u = u
+         *
+         * The argument value takes std::optional parameters, but the method
+         * may also be passed V directly which will then be boxed implicitly.
+         *
+         * @param i the index to coalesce at.
+         * @param v the value to coalesce with.
+         */
+        void coalesce_l(const I & i, const std::optional<V> & v);
+
+        /**
+         * @brief Coalesce a single value in the array, giving priority to the
+         * right hand side.
+         *
+         * Same as coalesce_l(), except the case analysis is as follows:
+         *
+         * v >> w = case (v, w) of:
+         *     _, Just u = Just u
+         *     u, _      = u
+         *
+         * @param i the index to coalesce at.
+         * @param v the value to coalesce with.
+         */
+        void coalesce_r(const I & i, const std::optional<V> & v);
+
+        /**
+         * @brief Mutable accessor to the underlying container.
+         *
+         * A simple mutable accessor to the underlying container of this class.
+         *
+         * @return a mutable reference to the underlying container.
+         */
+        F & data(void);
+
+        /**
+         * @brief Immutable accessor to the underlying container.
+         *
+         * A simple immutable accessor to the underlying container of this
+         * class.
+         *
+         * @return an immutable reference to the underlying container.
+         */
+        const F & data(void) const;
+
+    protected:
+        F m_data;
+    };
+
+    /**
+     * @brief Specialization of OptionalBase indexed by discrete, countable
+     * indices.
+     *
+     * If we know that our indices are contiguous and discrete, this allows us
+     * additional power, such as allowing us to coalesce over the entire set of
+     * values.
+     *
+     * Template parameters are the same as for OptionalBase.
+     */
+    template<template <typename> typename C, typename I, typename V>
+    class OptionalArrayLike : public OptionalBase<C, I, V> {
+        static_assert(
+            is_static_castable<I, std::size_t>::value,
+            "Index type must be castable to std::size_t!"
+        );
+
+    public:
+        /**
+         * @brief Coalesce this array with another, giving priority to the left
+         * hand side.
+         *
+         * Updates the values in the array according to the data in the right
+         * hand side array, giving priority to the left hand side. This method
+         * changes the values of the array on which it is called.
+         *
+         * For example, if we abuse notation and write left-coalesce as <<, we
+         * find the following:
+         *
+         * [5, {}, 7, {}] << [2, 9, {}, {}] = [5, 9, 7, {}]
+         *
+         * @param rhs the right hand side array.
+         */
+        void coalesce_all_l(const OptionalArrayLike<C, I, V> & rhs);
+
+        /**
+         * @brief Coalesce this array with another, giving priority to the
+         * right hand side.
+         *
+         * See coalesce_l() for more information. As an example, if we abuse
+         * notation and write right-coalesce as >>, we find the following:
+         *
+         * [5, {}, 7, {}] >> [2, 9, {}, {}] = [2, 9, 7, {}]
+         *
+         * @param rhs the right hand side track summary.
+         */
+        void coalesce_all_r(const OptionalArrayLike<C, I, V> & rhs);
+    };
+
+    /**
+     * @brief An alias to a specialization of an optional array.
+     *
+     * This is the only pecialization we provide so far, and it's for the array
+     * backend. The template arguments are compatible with those of std::array,
+     * with the exception that it can optionally take an indexing type as well.
+     *
+     * @tparam V the underlying value type.
+     * @tparam N the size of the array.
+     * @tparam I the indexing type, size_t by default.
+     *
+     * This is where our PartiallyAppliedArray class comes into play, as it
+     * allows us to create a partially applied array type of given size.
+     */
+    template<typename V, std::size_t N, typename I=std::size_t>
+    using OptionalArray = OptionalArrayLike<PartiallyAppliedArray<N>::template type, I, V>;
+}
+
+#include "CxxUtils/OptionalContainer.icc"
+
+#endif

Control/CxxUtils/CxxUtils/OptionalContainer.icc

+/*
+* Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+* @file CxxUtils/OptionalContainer.icc
+* @author Stephen Nicholas Swatman <stephen.nicholas.swatman@cern.ch>
+* @date September 2020
+* @brief A container of optional values, with ergonomic methods.
+*/
+
+template<template <typename> typename C, typename I, typename V>
+bool CxxUtils::OptionalBase<C, I, V>::is_set(const I & i) const {
+    return this->get(i).has_value();
+}
+
+template<template <typename> typename C, typename I, typename V>
+template<typename W>
+bool CxxUtils::OptionalBase<C, I, V>::update(const I & i, W && v) {
+    static_assert(std::is_convertible<V, std::remove_reference_t<W>>::value);
+
+    if (this->get(i).has_value()) {
+        this->get(i) = std::forward<W>(v);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template<template <typename> typename C, typename I, typename V>
+template<typename W>
+bool CxxUtils::OptionalBase<C, I, V>::set_if_unset(const I & i, W && v) {
+    static_assert(std::is_convertible<V, std::remove_reference_t<W>>::value);
+
+    if (this->get(i).has_value()) {
+        return false;
+    } else {
+        this->get(i) = std::forward<W>(v);
+        return true;
+    }
+}
+
+template<template <typename> typename C, typename I, typename V>
+template<typename W>
+bool CxxUtils::OptionalBase<C, I, V>::set(const I & i, W && v) {
+    static_assert(std::is_convertible<V, std::remove_reference_t<W>>::value);
+
+    this->get(i) = std::forward<W>(v);
+    return true;
+}
+
+template<template <typename> typename C, typename I, typename V>
+void CxxUtils::OptionalBase<C, I, V>::unset(const I & i) {
+    this->get(i).reset();
+}
+
+template<template <typename> typename C, typename I, typename V>
+void CxxUtils::OptionalBase<C, I, V>::increment(const I & i) {
+    this->set_if_unset(i, static_cast<V>(0));
+    (*this->get(i))++;
+}
+
+template<template <typename> typename C, typename I, typename V>
+const std::optional<V> & CxxUtils::OptionalBase<C, I, V>::get(const I & i) const {
+    return this->m_data[static_cast<typename F::size_type>(i)];
+}
+
+template<template <typename> typename C, typename I, typename V>
+std::optional<V> & CxxUtils::OptionalBase<C, I, V>::get(const I & i) {
+    return this->m_data[static_cast<typename F::size_type>(i)];
+}
+
+template<template <typename> typename C, typename I, typename V>
+void CxxUtils::OptionalBase<C, I, V>::coalesce_l(const I & i, const std::optional<V> & v) {
+    if (v.has_value()) {
+        this->set_if_unset(i, *v);
+    }
+}
+
+template<template <typename> typename C, typename I, typename V>
+void CxxUtils::OptionalBase<C, I, V>::coalesce_r(const I & i, const std::optional<V> & v) {
+    if (v.has_value()) {
+        this->set(i, *v);
+    }
+}
+
+template<template <typename> typename C, typename I, typename V>
+auto CxxUtils::OptionalBase<C, I, V>::data(void) -> F & {
+    return m_data;
+}
+
+template<template <typename> typename C, typename I, typename V>
+auto CxxUtils::OptionalBase<C, I, V>::data(void) const -> const F & {
+    return m_data;
+}
+
+template<template <typename> typename C, typename I, typename V>
+void CxxUtils::OptionalArrayLike<C, I, V>::coalesce_all_l(const OptionalArrayLike<C, I, V> & rhs) {
+    for (size_t i = 0; i < std::min(this->m_data.size(), rhs.m_data.size()); i++) {
+        this->coalesce_l(i, rhs.get(i));
+    }
+}
+
+template<template <typename> typename C, typename I, typename V>
+void CxxUtils::OptionalArrayLike<C, I, V>::coalesce_all_r(const OptionalArrayLike<C, I, V> & rhs) {
+    for (size_t i = 0; i < std::min(this->m_data.size(), rhs.m_data.size()); i++) {
+        this->coalesce_r(i, rhs.get(i));
+    }
+}

Control/CxxUtils/test/OptionalContainer_test.cxx

+#undef NDEBUG
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+
+#include "CxxUtils/OptionalContainer.h"
+
+
+class Test {
+public:
+    Test(int v) : m_t(v) {
+
+    };
+
+    int get() {
+        return m_t;
+    };
+private:
+    int m_t;
+};
+
+
+enum class TestEnum {
+    Nil = 0,
+    One = 1,
+    Two = 2,
+    Three = 3,
+    Max = 4
+};
+
+
+void test_init(void) {
+    CxxUtils::OptionalArray<int, 2> A1;
+
+    assert(!A1.get(0).has_value());
+    assert(!A1.get(1).has_value());
+}
+
+void test_set(void) {
+    CxxUtils::OptionalArray<int, 3> A1;
+
+    assert(A1.set_if_unset(0, 5));
+    assert(!A1.set_if_unset(0, 2));
+    assert(A1.set_if_unset(1, 6));
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(!A1.is_set(2));
+
+    assert(A1.get(0) == 5);
+    assert(A1.get(1) == 6);
+}
+
+void test_copy_ctor(void) {
+    CxxUtils::OptionalArray<int, 3> A1;
+
+    A1.set_if_unset(0, 5);
+    A1.set_if_unset(1, 6);
+
+    CxxUtils::OptionalArray<int, 3> A2(A1);
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(!A1.is_set(2));
+
+    assert(A1.get(0) == 5);
+    assert(A1.get(1) == 6);
+
+    assert(A2.is_set(0));
+    assert(A2.is_set(1));
+    assert(!A2.is_set(2));
+
+    assert(A2.get(0) == 5);
+    assert(A2.get(1) == 6);
+}
+
+void test_copy_op(void) {
+    CxxUtils::OptionalArray<int, 3> A1;
+
+    A1.set_if_unset(0, 5);
+    A1.set_if_unset(1, 6);
+
+    CxxUtils::OptionalArray<int, 3> A2 = A1;
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(!A1.is_set(2));
+
+    assert(A1.get(0) == 5);
+    assert(A1.get(1) == 6);
+
+    assert(A2.is_set(0));
+    assert(A2.is_set(1));
+    assert(!A2.is_set(2));
+
+    assert(A2.get(0) == 5);
+    assert(A2.get(1) == 6);
+}
+
+void test_update(void) {
+    CxxUtils::OptionalArray<int, 3> A1;
+
+    assert(A1.set_if_unset(0, 5));
+    assert(A1.set_if_unset(1, 6));
+
+    assert(A1.update(0, 2));
+    assert(A1.update(1, 7));
+    assert(!A1.update(2, 5));
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(!A1.is_set(2));
+
+    assert(A1.get(0) == 2);
+    assert(A1.get(1) == 7);
+}
+
+void test_upset(void) {
+    CxxUtils::OptionalArray<int, 3> A1;
+
+    assert(A1.set_if_unset(0, 5));
+    assert(A1.set_if_unset(1, 6));
+
+    assert(A1.set(0, 2));
+    assert(A1.set(1, 7));
+    assert(A1.set(2, 5));
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(A1.is_set(2));
+
+    assert(A1.get(0) == 2);
+    assert(A1.get(1) == 7);
+    assert(A1.get(2) == 5);
+}
+
+void test_unset(void) {
+    CxxUtils::OptionalArray<int, 3> A1;
+
+    assert(A1.set_if_unset(0, 5));
+    assert(A1.set_if_unset(1, 6));
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(!A1.is_set(2));
+
+    A1.unset(1);
+
+    assert(A1.is_set(0));
+    assert(!A1.is_set(1));
+    assert(!A1.is_set(2));
+}
+
+void test_increment(void) {
+    CxxUtils::OptionalArray<int, 3> A1;
+
+    assert(A1.set_if_unset(0, 5));
+
+    assert(A1.is_set(0));
+    assert(!A1.is_set(1));
+    assert(!A1.is_set(2));
+
+    A1.increment(0);
+    A1.increment(1);
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(!A1.is_set(2));
+
+    assert(A1.get(0) == 6);
+    assert(A1.get(1) == 1);
+}
+
+void test_coalese_l_whole(void) {
+    CxxUtils::OptionalArray<int, 4> A1;
+    CxxUtils::OptionalArray<int, 4> A2;
+
+    A1.set_if_unset(0, 5);
+    A1.set_if_unset(1, 7);
+
+    A2.set_if_unset(0, 11);
+    A2.set_if_unset(2, 9);
+
+    A1.coalesce_all_l(A2);
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(A1.is_set(2));
+    assert(!A1.is_set(3));
+
+    assert(A1.get(0) == 5);
+    assert(A1.get(1) == 7);
+    assert(A1.get(2) == 9);
+}
+
+void test_coalese_r_whole(void) {
+    CxxUtils::OptionalArray<int, 4> A1;
+    CxxUtils::OptionalArray<int, 4> A2;
+
+    A1.set_if_unset(0, 5);
+    A1.set_if_unset(1, 7);
+
+    A2.set_if_unset(0, 11);
+    A2.set_if_unset(2, 9);
+
+    A1.coalesce_all_r(A2);
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(A1.is_set(2));
+    assert(!A1.is_set(3));
+
+    assert(A1.get(0) == 11);
+    assert(A1.get(1) == 7);
+    assert(A1.get(2) == 9);
+}
+
+void test_coalese_l_value(void) {
+    CxxUtils::OptionalArray<int, 4> A1;
+    std::optional<int> V1 = 3;
+    std::optional<int> V2 = {};
+    std::optional<int> V3 = 9;
+    std::optional<int> V4 = {};
+
+    A1.set_if_unset(0, 5);
+    A1.set_if_unset(1, 7);
+
+    A1.coalesce_l(0, V1);
+    A1.coalesce_l(1, V2);
+    A1.coalesce_l(2, V3);
+    A1.coalesce_l(3, V4);
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(A1.is_set(2));
+    assert(!A1.is_set(3));
+
+    assert(A1.get(0) == 5);
+    assert(A1.get(1) == 7);
+    assert(A1.get(2) == 9);
+}
+
+void test_coalese_r_value(void) {
+    CxxUtils::OptionalArray<int, 4> A1;
+    std::optional<int> V1 = 3;
+    std::optional<int> V2 = {};
+    std::optional<int> V3 = 9;
+    std::optional<int> V4 = {};
+
+    A1.set_if_unset(0, 5);
+    A1.set_if_unset(1, 7);
+
+    A1.coalesce_r(0, V1);
+    A1.coalesce_r(1, V2);
+    A1.coalesce_r(2, V3);
+    A1.coalesce_r(3, V4);
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(A1.is_set(2));
+    assert(!A1.is_set(3));
+
+    assert(A1.get(0) == 3);
+    assert(A1.get(1) == 7);
+    assert(A1.get(2) == 9);
+}
+
+void test_coalese_upcast_value(void) {
+    CxxUtils::OptionalArray<int, 8> A1;
+
+    A1.coalesce_l(0, 5);
+    assert(A1.is_set(0));
+    assert(A1.get(0) == 5);
+    A1.coalesce_r(0, 3);
+    assert(A1.is_set(0));
+    assert(A1.get(0) == 3);
+
+    A1.coalesce_l(1, {});
+    assert(!A1.is_set(1));
+    A1.coalesce_r(1, 5);
+    assert(A1.is_set(1));
+    assert(A1.get(1) == 5);
+
+    A1.coalesce_l(2, 2);
+    assert(A1.is_set(2));
+    assert(A1.get(2) == 2);
+    A1.coalesce_r(2, {});
+    assert(A1.is_set(2));
+    assert(A1.get(2) == 2);
+
+    A1.coalesce_l(3, {});
+    assert(!A1.is_set(3));
+    A1.coalesce_r(3, {});
+    assert(!A1.is_set(3));
+}
+
+void test_copyable_type(void) {
+    CxxUtils::OptionalArray<Test, 8> A1;
+
+    Test t1(5);
+    Test t2(7);
+    const Test t3(9);
+    const Test t4(11);
+
+    A1.set_if_unset(0, Test(1));
+    A1.set_if_unset(1, t1);
+    A1.set_if_unset(2, std::move(t2));
+    A1.set_if_unset(3, t3);
+    A1.set_if_unset(4, std::move(t4));
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(A1.is_set(2));
+    assert(A1.is_set(3));
+    assert(A1.is_set(4));
+
+    assert(A1.get(0)->get() == 1);
+    assert(A1.get(1)->get() == 5);
+    assert(A1.get(2)->get() == 7);
+    assert(A1.get(3)->get() == 9);
+    assert(A1.get(4)->get() == 11);
+}
+
+void test_non_copyable_type(void) {
+    CxxUtils::OptionalArray<std::unique_ptr<int>, 8> A1;
+
+    std::unique_ptr<int> t1(new int(5));
+    std::unique_ptr<int> t2 = std::make_unique<int>(7);
+
+    A1.set_if_unset(0, std::make_unique<int>(1));
+    A1.set_if_unset(1, std::move(t1));
+    A1.set_if_unset(2, std::move(t2));
+
+    assert(A1.is_set(0));
+    assert(A1.is_set(1));
+    assert(A1.is_set(2));
+
+    assert(**A1.get(0) == 1);
+    assert(**A1.get(1) == 5);
+    assert(**A1.get(2) == 7);
+}
+
+void test_class_enum_index(void) {
+    CxxUtils::OptionalArray<int, static_cast<size_t>(TestEnum::Max), TestEnum> A1;
+
+    A1.set_if_unset(TestEnum::Nil, 2);
+    A1.set_if_unset(TestEnum::One, 3);
+    A1.set_if_unset(TestEnum::Two, 4);
+    A1.set_if_unset(TestEnum::Three, 5);
+
+    assert(A1.is_set(TestEnum::Nil));
+    assert(A1.is_set(TestEnum::One));
+    assert(A1.is_set(TestEnum::Two));
+    assert(A1.is_set(TestEnum::Three));
+
+    assert(*A1.get(TestEnum::Nil) == 2);
+    assert(*A1.get(TestEnum::One) == 3);
+    assert(*A1.get(TestEnum::Two) == 4);
+    assert(*A1.get(TestEnum::Three) == 5);
+}
+
+void test_implicit_convert() {
+    CxxUtils::OptionalArray<float, 2> A1;
+
+    assert(!A1.is_set(0));
+    assert(!A1.is_set(1));
+
+    A1.set_if_unset(0, 5);
+    assert(A1.is_set(0));
+    A1.update(0, 6);
+    assert(A1.is_set(0));
+    A1.set(0, 8);
+    assert(A1.is_set(0));
+
+    assert(*A1.get(0) == 8.0);
+}
+
+int main() {
+    test_init();
+    test_set();
+    test_copy_ctor();
+    test_copy_op();
+    test_update();
+    test_upset();
+    test_unset();
+    test_increment();
+    test_coalese_l_whole();
+    test_coalese_r_whole();
+    test_coalese_l_value();
+    test_coalese_r_value();
+    test_coalese_upcast_value();
+    test_copyable_type();
+    test_non_copyable_type();
+    test_class_enum_index();
+    test_implicit_convert();
+    return 0;
+}

Database/APR/CollectionBase/CollectionBase/CollectionColumn.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef COLLECTIONBASE_COLLECTIONCOLUMN_H
@@ -44,7 +44,7 @@ namespace pool {
      */
     CollectionColumn( const std::string& name,
                       const std::string& type,
-                      std::string fragmentName = "",
+                      const std::string& fragmentName = "",
                       int maxSize = 0,
                       bool sizeIsFixed = true )
       : m_name( name ),

Database/APR/CollectionBase/CollectionBase/CollectionDescription.h

@@ -47,8 +47,8 @@ namespace pool {
      */
     CollectionDescription( const std::string& name,
                            const std::string& type,
-                           std::string connection = "",
-                           std::string eventReferenceColumnName = "" );
+                           const std::string& connection = "",
+                           const std::string& eventReferenceColumnName = "" );
     
     /**
      * Copy constructor.

Database/APR/CollectionBase/CollectionBase/CollectionFactory.h

@@ -211,7 +211,7 @@ namespace pool {
      * @param name Name of collection.
      * @param physicalName physical name of collection in catalog.
      */    
-    void extract( const std::string physicalName,
+    void extract( const std::string& physicalName,
                   std::string& type, 
                   std::string& connection,
                   std::string& name ) const;    

Database/APR/CollectionBase/CollectionBase/CollectionFragment.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef COLLECTIONBASE_COLLECTIONFRAGMENT_H
@@ -38,7 +38,7 @@ namespace pool {
      * @param usesForeignKey Flag indicating whether fragment uses foreign key to reference parent fragment.
      */
     CollectionFragment( const std::string& name,
-                        std::string parentFragmentName = "",
+                        const std::string& parentFragmentName = "",
                         bool usesForeignKey = true )
       : m_name( name ),
         m_parentFragmentName( parentFragmentName ),

Database/APR/CollectionBase/src/CollectionDescription.cpp

@@ -20,8 +20,8 @@ using namespace std;
 
 pool::CollectionDescription::CollectionDescription( const std::string& name,
                                                     const std::string& type,
-                                                    std::string connection,
-                                                    std::string eventReferenceColumnName ) 
+                                                    const std::string& connection,
+                                                    const std::string& eventReferenceColumnName ) 
   : m_name( name ),
     m_type( type ),
     m_connection( connection ),
@@ -343,7 +343,7 @@ pool::CollectionDescription::setName( const std::string& name )
       // rename frament in column map
       for( std::map< std::string, std::string >::iterator colI = m_fragmentNameForColumnName.begin();
 	   colI != m_fragmentNameForColumnName.end();
-	   colI++ ) {
+	   ++colI ) {
 	 if( colI->second == m_name ) {
 	    colI->second = name;
 	    // change the reference inside the column
@@ -409,7 +409,7 @@ pool::CollectionDescription::setColumnId( pool::CollectionColumn *column, int id
       while( column_iter != m_columnIdForColumnName.end() ) {
 	 if( id < column_iter->second )
 	    id = column_iter->second;
-	 column_iter++;
+	 ++column_iter;
       }
       id++;
    }
@@ -869,8 +869,8 @@ pool::CollectionDescription::createIndex( std::string indexName, const std::vect
   // Generate unique name for index.
   if( !indexName.size() ) {
      indexName = fragmentName;
-     for( std::vector< std::string >::const_iterator iName = columnNames.begin(); iName != columnNames.end(); iName++ )     {
-	indexName += "_" + *iName; 
+     for (const std::string& name : columnNames) {
+	indexName += "_" + name; 
      }
      indexName += "_IDX";
   }
@@ -1023,9 +1023,9 @@ setUniqueConstraint( std::string constraintName, const std::vector< std::string
   if( !constraintName.size() ) {
      // Generate unique name for unique constraint.
      constraintName = fragmentName;
-     for ( std::vector< std::string >::const_iterator iName = columnNames.begin(); iName != columnNames.end(); iName++ )
+     for (const std::string& name : columnNames)
      {
-	constraintName += "_" + *iName; 
+	constraintName += "_" + name; 
      }
      constraintName += "_UC";
   }
@@ -1109,7 +1109,7 @@ pool::CollectionDescription::unsetUniqueConstraint( const std::vector< std::stri
       delete *iConstraint;
       iConstraint = m_uniqueConstraints.erase( iConstraint );
       for ( std::map< std::string, pool::CollectionColumn* >::iterator iColumn = columnForColumnName.begin();
-            iColumn != columnForColumnName.end(); iColumn++ )
+            iColumn != columnForColumnName.end(); ++iColumn )
       {
         iColumn->second->setIsUnique( false );
       }

Database/APR/CollectionBase/src/CollectionFactory.cpp

@@ -466,7 +466,7 @@ pool::CollectionFactory::isUnique( const pool::FileCatalog::FileID& guid,
 
 
 void 
-pool::CollectionFactory::extract( const std::string physicalName,
+pool::CollectionFactory::extract( const std::string& physicalName,
                                   std::string& type,
                                   std::string& connection,
                                   std::string& name ) const

Database/APR/CollectionBase/src/TokenList.cpp

@@ -158,7 +158,7 @@ pool::TokenList::operator[]( unsigned int index ) const
 std::ostream&
 pool::TokenList::toOutputStream( std::ostream& os ) const
 {
-   for( size_t i = 0; i <= m_tokenVector.size(); ++i ) {
+   for( size_t i = 0; i < m_tokenVector.size(); ++i ) {
       os << "[" << m_tokenNames[i] << " (Token) : " << m_tokenVector[i]->toString()<< "]";
    }