CondCont.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "AthenaKernel/CondCont.h"
#include "AthenaKernel/getMessageSvc.h"
#include "AthenaKernel/ExtendedEventContext.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/MsgStream.h"
#include <iostream>
 

std::string CondContBase::s_cleanerSvcName = "Athena::ConditionsCleanerSvc";
 

int CondContBase::Compare::overlap (const EventContext& ctx,
                                    const RangeKey& oldRange,
                                    RangeKey& newRange) const
{
  //                              |--- oldRange ---|
  //  |--- newRange ---|
  if (newRange.m_stop <= oldRange.m_start) {
    return 0;
  }
        
  //  |--- oldRange ---|
  //                        |--- newRange ---|
  if (oldRange.m_stop <= newRange.m_start) {
    return 0;
  }
 
  //   |---     oldRange    ---|
  //      |--- newRange ---|
  if (newRange.m_start >= oldRange.m_start &&
      newRange.m_stop <= oldRange.m_stop)
  {
    return -1;
  }
 
  // Current IOV key.
  key_type cur;
  if (newRange.m_range.start().isTimeStamp()) {
    cur = keyFromTimestamp (ctx.eventID());
  }
  else {
    EventIDBase eid = ctx.eventID();
    if (ctx.hasExtension()) {
      EventIDBase::number_type conditionsRun =
        Atlas::getExtendedEventContext (ctx).conditionsRun();
      if (conditionsRun != EventIDBase::UNDEFNUM) {
        eid.set_run_number (conditionsRun);
      }
    }
    cur = keyFromRunLBN (eid);
  }
 
  // Either this:
  //      |---     oldRange    ---|
  //                 |--- newRange ---|
  //
  // Or this
  //      |---     oldRange    ---|
  //  |---               newRange ---|
  //  with the current IOV key after the end of oldRange.
  //
  // In either case, we start the start of newRange to the end of oldRange.
  if (newRange.m_stop > oldRange.m_stop &&
      (newRange.m_start >= oldRange.m_start ||
       cur > oldRange.m_stop))
  {
    newRange.m_start = oldRange.m_stop;
    if (oldRange.m_range.stop().isTimeStamp()) {
      // If this is a mixed key, we need to copy only the timestamp part.
      EventIDBase oldId = oldRange.m_range.stop();
      EventIDBase newId = newRange.m_range.start();
      newRange.m_range = EventIDRange (EventIDBase (newId.run_number(),
                                                    newId.event_number(),
                                                    oldId.time_stamp(),
                                                    oldId.time_stamp_ns_offset(),
                                                    newId.lumi_block(),
                                                    newId.bunch_crossing_id()),
                                       newRange.m_range.stop());
    }
    else {
      newRange.m_range = EventIDRange (oldRange.m_range.stop(),
                                       newRange.m_range.stop());
    }
  }
 
 
  //              |---     oldRange    ---|
  //      |--- newRange  ---|
  else if (newRange.m_start < oldRange.m_start &&
           newRange.m_stop > oldRange.m_start)
  {
    // Change the end of newRange to the start of oldRange.
    newRange.m_stop = oldRange.m_start;
    if (oldRange.m_range.start().isTimeStamp()) {
      // If this is a mixed key, we need to copy only the timestamp part.
      EventIDBase oldId = oldRange.m_range.start();
      EventIDBase newId = newRange.m_range.stop();
      newRange.m_range = EventIDRange (newRange.m_range.start(),
                                       EventIDBase (newId.run_number(),
                                                    newId.event_number(),
                                                    oldId.time_stamp(),
                                                    oldId.time_stamp_ns_offset(),
                                                    newId.lumi_block(),
                                                    newId.bunch_crossing_id()));
    }
    else {
      newRange.m_range = EventIDRange (newRange.m_range.start(),
                                       oldRange.m_range.start());
    }
  }
 
  // Should have handled all cases by now!
  else {
    std::abort();
  }
 
  return 1;
}
 

int CondContBase::Compare::extendRange (RangeKey& range,
                                        const RangeKey& newRange) const
{
  //      |--- range ---|
  //  |--- newRange ....
  if (newRange.m_start < range.m_start) {
    return 0;
  }
 
  //      |--- range ---|
  //                         |--- newRange ....
  if (newRange.m_start > range.m_stop) {
    return 0;
  }
 
  //      |--- range ----------------|
  //         |--- newRange ---|
  if (newRange.m_stop <= range.m_stop) {
    return -1;
  }
 
  //      |--- range ----|
  //         |--- newRange ---|
  range.m_stop = newRange.m_stop;
  range.m_range = EventIDRange (range.m_range.start(),
                                newRange.m_range.stop());
  return 1;
}
 

const char* CondContBase::Category::name() const
{
  return "CondCont";
}
 

std::string CondContBase::Category::message (code_t code) const
{
  if (code == static_cast<code_t> (CondContStatusCode::DUPLICATE)) {
    return "DUPLICATE";
  }
  else if (code == static_cast<code_t> (CondContStatusCode::OVERLAP)) {
    return "OVERLAP";
  }
  else if (code == static_cast<code_t> (CondContStatusCode::EXTENDED)) {
    return "EXTENDED";
  }
  return StatusCode::Category::message (code);
}
 

bool CondContBase::Category::isSuccess (code_t code) const
{
  return code == static_cast<code_t>( CondContStatusCode::DUPLICATE ) ||
    code == static_cast<code_t>( CondContStatusCode::OVERLAP ) ||
    code == static_cast<code_t>( CondContStatusCode::EXTENDED ) ||
    code == static_cast<code_t>( CondContStatusCode::SUCCESS );
}
 

bool CondContBase::Category::isDuplicate (code_t code)
{
  return code == static_cast<code_t> (CondContStatusCode::DUPLICATE);
}
 

bool CondContBase::Category::isDuplicate (StatusCode code)
{
  return isDuplicate (code.getCode());
}
 

bool CondContBase::Category::isOverlap (code_t code)
{
  return code == static_cast<code_t> (CondContStatusCode::OVERLAP);
}
 

bool CondContBase::Category::isOverlap (StatusCode code)
{
  return isOverlap (code.getCode());
}
 

bool CondContBase::Category::isExtended (code_t code)
{
  return code == static_cast<code_t> (CondContStatusCode::EXTENDED);
}
 

bool CondContBase::Category::isExtended (StatusCode code)
{
  return isExtended (code.getCode());
}
 
 
STATUSCODE_ENUM_IMPL (CondContStatusCode, CondContBase::Category)
 
 

void CondContBase::setProxy (SG::DataProxy* proxy)
{
  m_proxy = proxy;
}
 

void CondContBase::print() const
{
  list (std::cout);
}
 

size_t CondContBase::entries() const
{
  return m_condSet.size();
}
 

size_t CondContBase::trim (const std::vector<key_type>& runLbnKeys, const std::vector<key_type>& TSKeys)
{
  if (m_keyType == KeyType::RUNLBN) {
      return m_condSet.trim (runLbnKeys);
  }
 
  if (m_keyType == KeyType::TIMESTAMP) {
    return m_condSet.trim ( TSKeys );
  }
 
 
  if (m_keyType == KeyType::MIXED) {
    //For mixed containers, first trim inner container based in TimeStamps
    size_t nTrimmed=0;
    for (const typename CondContSet::value_type& ent : m_condSet.range()) {
      const CondContSet* tsmap = reinterpret_cast<const CondContSet*> (ent.second);
      //size_t before=tsmap->size();
      CondContSet* tsmap_nc ATLAS_THREAD_SAFE = const_cast<CondContSet*>(tsmap);
      // Trim inner containers, allowing the removal of all elements.
      // See ATLASRECTS-7421.
      size_t ntrim=tsmap_nc->trim (TSKeys, true);
      nTrimmed+=ntrim;
      //std::cout << "WL: Trimming inner container for clid " << m_clid << " (" << ntrim << " out of " << before << ", nKeys= " << TSKeys.size() << ")" << std::endl;
    }
    // Then trim outer container based on run-LB.
    size_t outerTrimmed=m_condSet.trim(runLbnKeys);
    //std::cout << "WL: Removing outer sets " << outerTrimmed << ", remaining " << m_condSet.size()  << std::endl; 
    //FIXME: The number returned may be inaccurate, only correct if the outer container
    //has exactly one element left by the time it gets removed.  
    return nTrimmed+outerTrimmed; 
  }
 
//Arrive here for KeyType::SINGLE .. do nothing. 
 return 0;
}
 

void CondContBase::clear()
{
  m_condSet.clear();
}
 

 * Defined here for purposes of testing.
 */
void
CondContBase::quiescent (const EventContext& ctx)
{
  m_condSet.quiescent (ctx);
}
 

size_t CondContBase::nInserts() const
{
  return m_condSet.nInserts();
}
 

size_t CondContBase::maxSize() const
{
  return m_condSet.maxSize();
}
 

CondContBase::CondContBase (Athena::IRCUSvc& rcusvc,
                            KeyType keyType,
                            CLID clid,
                            const DataObjID& id,
                            SG::DataProxy* proxy,
                            std::shared_ptr<CondContSet::IPayloadDeleter> payloadDeleter,
                            size_t capacity)
  : m_keyType (keyType),
    m_clid (clid),
    m_id (id),
    m_proxy (proxy),
    m_condSet (Updater_t (rcusvc), std::move(payloadDeleter), capacity),
    m_cleanerSvc (s_cleanerSvcName, "CondContBase"),
    m_deps (DepSet::Updater_t(), 16)
{
  if (!m_cleanerSvc.retrieve().isSuccess()) {
    std::abort();
  }
}
 

StatusCode
CondContBase::insertBase (const EventIDRange& r,
                          CondContSet::payload_unique_ptr t,
                          const EventContext& ctx)
{
  EventIDBase start = r.start();
  EventIDBase stop = r.stop();
 
  key_type start_key, stop_key;
 
  if (m_keyType == KeyType::MIXED) {
    if (start.run_number() == EventIDBase::UNDEFNUM ||
        stop.run_number() == EventIDBase::UNDEFNUM)
    {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::insertBase: "
          << "Run part of range invalid in mixed container."
          << endmsg;
      return StatusCode::FAILURE;
    }
 
    start_key = keyFromRunLBN (start);
    stop_key  = keyFromRunLBN (stop);
  }
  else if (start.isTimeStamp() && stop.isTimeStamp()) {
    if (m_keyType == KeyType::SINGLE) {
      m_keyType = KeyType::TIMESTAMP;
    }
    else if (m_keyType != KeyType::TIMESTAMP) {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::insertBase: "
          << "Timestamp key used in non-timestamp container."
          << endmsg;
      return StatusCode::FAILURE;
    }
 
    start_key = keyFromTimestamp (start);
    stop_key  = keyFromTimestamp (stop);
  }
 
  else if (start.run_number() != EventIDBase::UNDEFNUM &&
           stop.run_number() != EventIDBase::UNDEFNUM)
  {
    if (m_keyType == KeyType::SINGLE) {
      m_keyType = KeyType::RUNLBN;
    }
    else if (m_keyType != KeyType::RUNLBN) {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::insertBase: "
          << "Run/LBN key used in non-Run/LBN container."
          << endmsg;
      return StatusCode::FAILURE;
    }
 
    start_key = keyFromRunLBN (start);
    stop_key  = keyFromRunLBN (stop);
  }
 
  else {
    MsgStream msg (Athena::getMessageSvc(), title());
    msg << MSG::ERROR << "CondContBase::insertBase: EventIDRange " << r 
        << " is neither fully RunEvent nor TimeStamp" 
        << endmsg;
    return StatusCode::FAILURE;
  }
 
  CondContSet::EmplaceResult reslt =
    m_condSet.emplace( RangeKey(r, start_key, stop_key),
                       std::move(t),
                       m_keyType != KeyType::MIXED,
                       ctx );
 
  if (reslt == CondContSet::EmplaceResult::DUPLICATE)
  {
    return CondContStatusCode::DUPLICATE;
  }
  else if (reslt == CondContSet::EmplaceResult::EXTENDED)
  {
    return CondContStatusCode::EXTENDED;
  }
  else if (reslt == CondContSet::EmplaceResult::OVERLAP) {
    return CondContStatusCode::OVERLAP;
  }
 
  return this->inserted (ctx);
}
 

StatusCode
CondContBase::eraseBase (const EventIDBase& t,
                         const EventContext& ctx)
{
  switch (m_keyType) {
  case KeyType::RUNLBN:
    if (!t.isRunLumi()) {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::erase: "
          << "Non-Run/LBN key used in Run/LBN container."
          << endmsg;
      return StatusCode::FAILURE;
    }
    m_condSet.erase (CondContBase::keyFromRunLBN (t), ctx);
    break;
  case KeyType::TIMESTAMP:
    if (!t.isTimeStamp()) {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::erase: "
          << "Non-Timestamp key used in timestamp container."
          << endmsg;
      return StatusCode::FAILURE;
    }
    m_condSet.erase (CondContBase::keyFromTimestamp (t), ctx);
    break;
  case KeyType::SINGLE:
    break;
  default:
    std::abort();
  }
  return StatusCode::SUCCESS;
}
 

StatusCode
CondContBase::extendLastRangeBase (const EventIDRange& newRange,
                                   const EventContext& ctx)
{
  key_type start;
  key_type stop;
  switch (m_keyType) {
  case KeyType::RUNLBN:
  case KeyType::MIXED:  // To handle the extension case of insertMixed().
    if (!newRange.start().isRunLumi()) {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::extendLastRange: "
          << "Non-Run/LBN range used in Run/LBN container."
          << endmsg;
      return StatusCode::FAILURE;
    }
    start = keyFromRunLBN (newRange.start());
    stop  = keyFromRunLBN (newRange.stop());
    break;
  case KeyType::TIMESTAMP:
    if (!newRange.start().isTimeStamp()) {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::extendLastRange: "
          << "Non-timestamp range used in timestamp container."
          << endmsg;
      return StatusCode::FAILURE;
    }
    start = keyFromTimestamp (newRange.start());
    stop  = keyFromTimestamp (newRange.stop());
    break;
  case KeyType::SINGLE:
    // Empty container.
    return StatusCode::FAILURE;
  default:
    std::abort();
  }
  
  if (m_condSet.extendLastRange (RangeKey (newRange, start, stop), ctx) >= 0)
  {
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}
 

const void* CondContBase::findBase (const EventIDBase& t,
                                    EventIDRange const** r) const
{
  const void* ptr = nullptr;
  key_type key;
  switch (m_keyType) {
  case KeyType::RUNLBN:
  case KeyType::MIXED:
    if (!t.isRunLumi()) [[unlikely]] {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::findBase: "
          << "Non-Run/LBN key used in Run/LBN container."
          << endmsg;
      return nullptr;
    }
    key = keyFromRunLBN (t);
    break;
  case KeyType::TIMESTAMP:
    if (!t.isTimeStamp()) [[unlikely]] {
      MsgStream msg (Athena::getMessageSvc(), title());
      msg << MSG::ERROR << "CondContBase::findBase: "
          << "Non-timestamp key used in timestamp container."
          << endmsg;
      return nullptr;
    }
    key = keyFromTimestamp (t);
    break;
  case KeyType::SINGLE:
    // Empty container.
    return nullptr;
  default:
    std::abort();
  }
 
  CondContSet::const_iterator it = m_condSet.find (key);
  if (it && key < it->first.m_stop) {
    if (r) {
      *r = &it->first.m_range;
    }
    ptr = it->second;
  } 
 
  return ptr;
}
 

StatusCode CondContBase::inserted (const EventContext& ctx)
{
  return m_cleanerSvc->condObjAdded (ctx, *this);
}
 

void CondContBase::addDep (CondContBase* dep)
{
  m_deps.insert (dep);
}
 

std::vector<CondContBase*> CondContBase::getDeps()
{
  return std::vector<CondContBase*> (m_deps.begin(), m_deps.end());
}
 
 

void CondContBase::setCleanerSvcName (const std::string& name)
{
  s_cleanerSvcName = name;
}
 

void CondContBase::insertError (CLID usedCLID) const
{
  MsgStream msg (Athena::getMessageSvc(), title());
  msg << MSG::ERROR << "CondCont<T>::insert: Not most-derived class; "
      << "CLID used: " << usedCLID
      << "; container CLID: " << m_clid
      << endmsg;
}
 

CondContBase::delete_function* CondContBase::delfcn() const
{
  return m_condSet.deleter().delfcn();
}
 

std::string CondContBase::title() const
{
  return m_id.fullKey();
}
 
 
//****************************************************************************
 

void CondContSingleBase::list (std::ostream& ost) const
{
  ost << "id: " << id() << "  proxy: " << proxy() << " ["
      << entries() << "] entries" << std::endl;
  forEach ([&] (const CondContSet::value_type& ent)
           { ost << ent.first.m_range << " " << ent.second << std::endl; });
}
 

/**
 * @brief Return all IOV validity ranges defined in this container.
 */
std::vector<EventIDRange> 
CondContSingleBase::ranges() const
{
  std::vector<EventIDRange> r;
  r.reserve (entries());
 
  forEach ([&] (const CondContSet::value_type& ent)
           { r.push_back (ent.first.m_range); });
 
  return r;
}
 

StatusCode
CondContSingleBase::typelessInsert (const EventIDRange& r,
                                    void* obj,
                                    const EventContext& ctx)
{
  return insertBase (r,
                     CondContSet::payload_unique_ptr (obj, delfcn()),
                     ctx);
}
 

bool
CondContSingleBase::range (const EventIDBase& t, EventIDRange& r) const
{
  const EventIDRange* rp = nullptr;
  if (findBase (t, &rp) != nullptr) {
    r = *rp;
    return true;
  }
  return false;
}
 

StatusCode
CondContSingleBase::erase (const EventIDBase& t,
                           const EventContext& ctx)
{
  return CondContBase::eraseBase (t, ctx);
}
 

StatusCode
CondContSingleBase::extendLastRange (const EventIDRange& newRange,
                                     const EventContext& ctx)
{
  return CondContBase::extendLastRangeBase (newRange, ctx);
}
 

CondContSingleBase::CondContSingleBase (Athena::IRCUSvc& rcusvc,
                                        CLID clid,
                                        const DataObjID& id,
                                        SG::DataProxy* proxy,
                                        std::shared_ptr<CondContSet::IPayloadDeleter> payloadDeleter,
                                        size_t capacity)
  : CondContBase (rcusvc, KeyType::SINGLE, clid, id, proxy,
                  std::move(payloadDeleter), capacity)
{
}
 
 
//****************************************************************************
 

CondContMixedBase::CondContMixedBase (Athena::IRCUSvc& rcusvc,
                                      CLID clid,
                                      const DataObjID& id,
                                      SG::DataProxy* proxy,
                                      std::shared_ptr<CondContSet::IPayloadDeleter> payloadDeleter,
                                      size_t capacity)
  : CondContBase (rcusvc, KeyType::MIXED, clid, id, proxy,
                  std::make_shared<Athena::CondObjDeleter<CondContSet> > (rcusvc),
                  capacity),
    m_rcusvc (rcusvc),
    m_payloadDeleter (std::move(payloadDeleter))
{
}
 

void CondContMixedBase::list (std::ostream& ost) const
{
  ost << "id: " << id() << "  proxy: " << proxy() << " ["
      << CondContBase::entries() << "] run+lbn entries" << std::endl;
  forEach ([&] (const CondContSet::value_type& ent)
           {
             const CondContSet* tsmap =
               reinterpret_cast<const CondContSet*> (ent.second);
             if (tsmap->empty()) {
               ost << ent.first.m_range << " (empty tsmap)" << std::endl;
             }
             else {
               for (const CondContSet::value_type& ent2 : tsmap->range()) {
                 ost << ent2.first.m_range << " " << ent2.second << std::endl;
               }
             }
           });
}
 

size_t CondContMixedBase::entries() const
{
  size_t nent = 0;
  forEach ([&] (const CondContSet::value_type& ent) {
    const CondContSet* tsmap =
      reinterpret_cast<const CondContSet*> (ent.second);
    nent += tsmap->size();
  });
  return nent;
}
 

std::vector<EventIDRange> 
CondContMixedBase::ranges() const
{
  std::vector<EventIDRange> r;
  r.reserve (entries()*2);
 
  forEach ([&] (const CondContSet::value_type& ent)
           {
             const CondContSet* tsmap =
               reinterpret_cast<const CondContSet*> (ent.second);
             for (const CondContSet::value_type& ent2 : tsmap->range()) {
               r.push_back (ent2.first.m_range);
             }
           });
 
  return r;
}
 

StatusCode
CondContMixedBase::typelessInsert (const EventIDRange& r,
                                   void* obj,
                                   const EventContext& ctx)
{
  return insertMixed (r,
                      CondContSet::payload_unique_ptr (obj, payloadDelfcn()),
                      ctx);
}
 

bool
CondContMixedBase::range (const EventIDBase& t, EventIDRange& r) const
{
  const EventIDRange* rp = nullptr;
  if (findMixed (t, &rp) != nullptr) {
    r = *rp;
    return true;
  }
  return false;
}
 

StatusCode
CondContMixedBase::erase (const EventIDBase& /*t*/,
                          const EventContext& /*ctx*/)
{
  MsgStream msg (Athena::getMessageSvc(), title());
  msg << MSG::ERROR << "CondContMixedBase::erase: "
      << "erase() is not implemented for mixed containers."
      << endmsg;
  return StatusCode::FAILURE;
}
 

StatusCode
CondContMixedBase::extendLastRange (const EventIDRange& /*newRange*/,
                                    const EventContext& /*ctx*/)
{
  MsgStream msg (Athena::getMessageSvc(), title());
  msg << MSG::ERROR << "CondContMixedBase::extendLastRange: "
      << "extendLastRange() is not implemented for mixed containers."
      << endmsg;
  return StatusCode::FAILURE;
}
 

StatusCode
CondContMixedBase::insertMixed (const EventIDRange& r,
                                CondContBase::CondContSet::payload_unique_ptr t,
                                const EventContext& ctx)
{
  // Serialize insertions.
  std::lock_guard<std::mutex> lock (m_mutex);
 
  const EventIDRange* range = nullptr;
  const void* tsmap_void = findBase (r.start(), &range);
  CondContSet* tsmap ATLAS_THREAD_SAFE =
    const_cast<CondContSet*>(reinterpret_cast<const CondContSet*> (tsmap_void));
 
  // Only test start timestamp.  stop timestamp may be missing
  // for open-ended ranges.
  key_type start_key=0; //If there is no TimeStamp in start, assume infinite range
  if (r.start().isTimeStamp() ) {
    start_key = keyFromTimestamp (r.start());
  }
 
  key_type stop_key  = keyFromTimestamp (r.stop());
 
  StatusCode sc = StatusCode::SUCCESS;
  sc.ignore();
  if (tsmap) {
    if (r.start().run_number() != range->start().run_number() ||
        r.stop().run_number() != range->stop().run_number() ||
        r.start().lumi_block() != range->start().lumi_block() ||
        r.stop().lumi_block() != range->stop().lumi_block())
    {
      // Run+lbn part doesn't match.  If this range contains only a single
      // timestamp range which matches the timestamp part of the key,
      // then try to extend it.  Otherwise, give an error.
 
      bool extended = false;
      if (tsmap->size() == 1) {
        CondContSet::const_iterator elt = tsmap->find (start_key);
        if (elt) {
          if (elt->first.m_start == start_key &&
              elt->first.m_stop == stop_key)
          {
            if (extendLastRangeBase (r, ctx).isSuccess())
            {
              sc = CondContStatusCode::EXTENDED;
              sc.ignore();
              extended = true;
 
              // We also need to update the ending run+lbn value
              // for each entry in the tsmap.
              // (This doesn't affect sorting within the tsmap.)
              // There's a potential race here: a lookup happening
              // between the extendLastRangeBase above and the updateRanges
              // below can get a range with an unupdated run/lbn.
              // It would be cleaner to do the extend/update as a single
              // operation, but for now we work around by having findMixed
              // retry if the run/lbn being sought is in the range
              // of the entry that's actually found.
              tsmap->updateRanges ([&] (RangeKey& k)
                                   { EventIDBase start = k.m_range.start();
                                     EventIDBase stop = k.m_range.stop();
                                     stop.set_run_number(r.stop().run_number());
                                     stop.set_lumi_block(r.stop().lumi_block());
                                     k.m_range = EventIDRange (start, stop);
                                   },
                                   ctx);
            }
          }
        }
      }
 
      if (!extended) {
        MsgStream msg (Athena::getMessageSvc(), title());
        msg << MSG::ERROR << "CondContMixedBase::insertMixed: "
            << "Run+lbn part of new range doesn't match existing range, "
            << "or can't extend. "
            << "New: " << r << "; existing: " << *range
            << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
  else {
    auto newmap = std::make_unique<CondContSet>
      (Updater_t (m_rcusvc), m_payloadDeleter, 16);
    tsmap = newmap.get();
    sc = insertBase (r, std::move (newmap), ctx);
    if (sc.isFailure()) {
      return sc;
    }
    else if (Category::isDuplicate (sc)) {
      // Shouldn't happen...
      std::abort();
    }
  }
 
  CondContSet::EmplaceResult reslt =
    tsmap->emplace ( RangeKey(r, start_key, stop_key),
                     std::move(t), false, ctx );
 
  if (reslt == CondContSet::EmplaceResult::OVERLAP) {
    return CondContStatusCode::OVERLAP;
  }
  else if (Category::isExtended (sc)) {
    return sc;
  }
  else if (reslt == CondContSet::EmplaceResult::DUPLICATE)
  {
    return CondContStatusCode::DUPLICATE;
  }
  else if (reslt == CondContSet::EmplaceResult::EXTENDED)
  {
    std::abort();  // Shouldn't happen.
  }
  return this->inserted (ctx);
  //return sc;
}
 

const void*
CondContMixedBase::findMixed (const EventIDBase& t,
                              EventIDRange const** r) const
{
  if (!t.isTimeStamp()) {
    MsgStream msg (Athena::getMessageSvc(), title());
    msg << MSG::ERROR << "CondContMixedBase::findMixed: "
        << "No valid timestamp in key used with mixed container."
        << endmsg;
    return nullptr;
  }
 
  auto dostall = []() { CxxUtils::stall(); return true; };
  const void* ptr = nullptr;
  CondContSet::const_iterator it;
  do {
    ptr = CondContBase::findBase (t, nullptr);
    if (!ptr) return nullptr;
 
    const CondContSet* tsmap = reinterpret_cast<const CondContSet*> (ptr);
    key_type key = keyFromTimestamp (t);
    it = tsmap->find (key);
 
    if (it && key < it->first.m_stop) {
      if (r) {
        *r = &it->first.m_range;
      }
      ptr = it->second;
    }
    else {
      ptr = nullptr;
    }
 
    // When we extend a range in a mixed container, the run/lbn fields
    // in the ts map are extended as a separate step.  This means
    // that there is a window in which we can successfully look up
    // an entry, but the range we get will have the old, unextended
    // run/lbn.  Work around here: if the run/lbn we're looking
    // for isn't in the range we get, then try again.
  } while (ptr &&
           keyFromRunLBN (t) >= keyFromRunLBN (it->first.m_range.stop()) &&
           dostall());
 
  return ptr;
}
 

CondContBase::delete_function* CondContMixedBase::payloadDelfcn() const
{
  return m_payloadDeleter->delfcn();
}