CondAttrListCollection.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef DBDATAOBJECTS_CONDATTRLISTCOLLECTION_H
#define DBDATAOBJECTS_CONDATTRLISTCOLLECTION_H 
 
 
#include "CoralBase/Attribute.h"
#include "CoralBase/AttributeList.h"
#include "CoralBase/AttributeListSpecification.h"
 
#include "AthenaKernel/IOVRange.h"
#include "AthenaKernel/CLASS_DEF.h"
#include "GaudiKernel/DataObject.h"
 
#include <map>
#include <sstream>
#include <vector>
 
 
class CondAttrListCollection : public DataObject
{
public:
 
    typedef unsigned int                               ChanNum;
    typedef coral::AttributeList                       AttributeList;
    typedef std::map<ChanNum, coral::AttributeList>    ChanAttrListMap;
    typedef ChanAttrListMap::value_type                ChanAttrListPair;
    typedef std::map<ChanNum, IOVRange>                ChanIOVMap;
    typedef ChanIOVMap::value_type                     ChanIOVPair;
    typedef std::map<ChanNum, std::string>             ChanNameMap;
    typedef ChanNameMap::value_type                    ChanNamePair;
    typedef ChanAttrListMap::const_iterator            const_iterator;
    typedef ChanAttrListMap::iterator                  iterator;
    typedef ChanAttrListMap::size_type                 size_type;
    typedef ChanIOVMap::const_iterator                 iov_const_iterator;
    typedef ChanIOVMap::iterator                       iov_iterator;
    typedef ChanIOVMap::size_type                      iov_size_type;
    typedef ChanNameMap::const_iterator                name_const_iterator;
    typedef ChanNameMap::iterator                      name_iterator;
    typedef ChanNameMap::size_type                     name_size_type;
    
    explicit CondAttrListCollection(bool hasRunLumiBlockTime);
 
    ~CondAttrListCollection();
 
    // copy constructor and assignment operator - have to be explicitly 
    // implemented to control use of the cached AttributeListSpecification
    CondAttrListCollection(const CondAttrListCollection& rhs);
    // no copy with new Gaudi
    CondAttrListCollection& operator=(const CondAttrListCollection& rhs) = delete;
 
    const_iterator      chanAttrListPair(ChanNum chanNum) const;
 
    const_iterator       begin() const;
    const_iterator       end  () const;
    
    size_type            size() const;
    
 
    iov_const_iterator   chanIOVPair(ChanNum chanNum) const;
 
    iov_const_iterator   iov_begin() const;
    iov_const_iterator   iov_end  () const;
    
    iov_size_type        iov_size() const;
 
    name_const_iterator  chanNamePair(ChanNum chanNum) const;
 
    name_const_iterator  name_begin() const;
    name_const_iterator  name_end() const;
 
    name_size_type       name_size() const;
 
    ChanNum              chanNum(unsigned int index) const;
 
    bool                 fixChanNum(ChanNum oldChan, ChanNum newChan);
    
    const AttributeList& attributeList(ChanNum chanNum) const;
    
    const IOVRange&      iovRange(ChanNum chanNum) const;
    
    const std::string&   chanName(ChanNum chanNum) const;
 
    const IOVRange&      minRange() const;
 
    bool                 hasUniqueIOV() const;
 
    bool                 add(ChanNum chanNum, const AttributeList& attributeList);
    void                 addShared(ChanNum chanNum, const AttributeList& attributeList);
 
    void                 add(ChanNum chanNum, const IOVRange& range);
 
    // Adding in chan/name pairs
    void                 add(ChanNum chanNum,const std::string& name);
 
    void                 addNewStart(const IOVTime& start);
 
    void                 addNewStop(const IOVTime& stop);
 
    void                 resetMinRange();
 
    void                 dump() const;
 
    void                 dump(std::ostringstream& stream) const;
 
    bool operator==( const CondAttrListCollection& rhs ) const;
 
    bool operator!=( const CondAttrListCollection& rhs ) const;
 
    bool                 isSameButMinRange ( const CondAttrListCollection& rhs,
                                             bool ignoreIOVs = false) const;
 
 
 
private:
 
    CondAttrListCollection();
 
    ChanAttrListMap m_attrMap;
    ChanIOVMap      m_iovMap;
    ChanNameMap     m_nameMap;
    IOVRange        m_minRange;
    bool            m_hasUniqueIOV;
    bool            m_hasRunLumiBlockTime;
    coral::AttributeListSpecification* m_spec;
};
 
CLASS_DEF(CondAttrListCollection, 1238547719, 0)
 
#include "AthenaKernel/CondCont.h"
CONDCONT_DEF( CondAttrListCollection, 1223307417 );
 
//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>
 
 
inline CondAttrListCollection::CondAttrListCollection()
:
m_minRange(IOVRange(IOVTime(IOVTime::MINRUN, IOVTime::MINEVENT),
                    IOVTime(IOVTime::MAXRUN, IOVTime::MAXEVENT))),
    m_hasUniqueIOV(true),
    m_hasRunLumiBlockTime(true),
    m_spec(nullptr)
{}
 
inline CondAttrListCollection::CondAttrListCollection(bool hasRunLumiBlockTime)
    :
    m_minRange(IOVRange(IOVTime(IOVTime::MINRUN, IOVTime::MINEVENT),
                IOVTime(IOVTime::MAXRUN, IOVTime::MAXEVENT))),
    m_hasUniqueIOV(true),
     m_hasRunLumiBlockTime(hasRunLumiBlockTime),
     m_spec(nullptr)
{
    if (!m_hasRunLumiBlockTime) {
        m_minRange = IOVRange(IOVTime(IOVTime::MINTIMESTAMP),
                              IOVTime(IOVTime::MAXTIMESTAMP));
    }
}
 
inline CondAttrListCollection::~CondAttrListCollection() {
  if (m_spec) m_spec->release();
}
 
inline CondAttrListCollection::CondAttrListCollection(
            const CondAttrListCollection& rhs) :
  DataObject::DataObject(rhs),
  m_iovMap(rhs.m_iovMap),
  m_nameMap(rhs.m_nameMap),
  m_minRange(rhs.m_minRange),
  m_hasUniqueIOV(rhs.m_hasUniqueIOV),
  m_hasRunLumiBlockTime(rhs.m_hasRunLumiBlockTime),
  m_spec(nullptr)
{
  // members with normal semantics setup in initialisation list
  // make a new cached AttributeListSpecificaiton and make the payload use it
  if (!rhs.m_attrMap.empty()) {
    m_spec=new coral::AttributeListSpecification();
    const coral::AttributeList& atr1=rhs.m_attrMap.begin()->second;
    for (const auto& attr : atr1) {
      const coral::AttributeSpecification& aspec=attr.specification();
      m_spec->extend(aspec.name(),aspec.typeName());
    }
    for (const auto& [chanNum, attrList] : rhs.m_attrMap) {
      auto newit = m_attrMap.try_emplace(chanNum, *m_spec, true).first;
      newit->second.fastCopyData(attrList);
    }
  }
}
 
// no copy with new Gaudi
// inline CondAttrListCollection& CondAttrListCollection::operator=(
//                  const CondAttrListCollection& rhs) {
//   // catch assignment to self - do nothing
//   if (this==&rhs) return *this;
//   // assign base class
//   DataObject::operator=(rhs);
//   // assign members with normal semantics
//   m_attrMap             = rhs.m_attrMap;
//   m_iovMap              = rhs.m_iovMap;
//   m_nameMap             = rhs.m_nameMap;
//   m_minRange            = rhs.m_minRange;
//   m_hasUniqueIOV        = rhs.m_hasUniqueIOV;
//   m_hasRunLumiBlockTime = rhs.m_hasRunLumiBlockTime;
//   // make a new cache AttributeListSpecification and make the payload map
//   // use it
//   if (m_spec!=0) m_spec->release();
//   if (rhs.m_attrMap.size()>0) {
//     m_spec = new coral::AttributeListSpecification();
//     const coral::AttributeList& atr1 = rhs.m_attrMap.begin()->second;
//     for (coral::AttributeList::const_iterator itr = atr1.begin();itr!=atr1.end();++itr) {
//       const coral::AttributeSpecification& aspec = itr->specification();
//       m_spec->extend(aspec.name(),aspec.typeName());
//     }
//     m_attrMap.clear();
//     const_iterator itr=rhs.m_attrMap.begin();
//     for (; itr != rhs.m_attrMap.end(); ++itr) {
//       m_attrMap[itr->first] = coral::AttributeList(*m_spec,true);
//       m_attrMap[itr->first].fastCopyData(itr->second);
//     }
//   } else {
//     m_spec = 0;
//   }
//   return *this;
// }
 
inline CondAttrListCollection::const_iterator
CondAttrListCollection::chanAttrListPair(ChanNum chanNum) const
{
    return (m_attrMap.find(chanNum));
}
 
 
inline CondAttrListCollection::const_iterator
CondAttrListCollection::begin() const
{
    return (m_attrMap.begin());
}
 
inline CondAttrListCollection::const_iterator 
CondAttrListCollection::end  () const
{
    return (m_attrMap.end());
}
 
inline CondAttrListCollection::size_type  
CondAttrListCollection::size() const
{
    return (m_attrMap.size());
}
 
 
inline CondAttrListCollection::iov_const_iterator
CondAttrListCollection::chanIOVPair(ChanNum chanNum) const
{
    return (m_iovMap.find(chanNum));
}
 
inline CondAttrListCollection::iov_const_iterator
CondAttrListCollection::iov_begin() const
{
    return (m_iovMap.begin());
}
 
inline CondAttrListCollection::iov_const_iterator
CondAttrListCollection::iov_end  () const
{
    return (m_iovMap.end());
}
    
inline CondAttrListCollection::iov_size_type 
CondAttrListCollection::iov_size() const
{
    return (m_iovMap.size());
}
 
inline CondAttrListCollection::name_const_iterator
CondAttrListCollection::chanNamePair(ChanNum chanNum) const
{
    return (m_nameMap.find(chanNum));
}
 
inline CondAttrListCollection::name_const_iterator
CondAttrListCollection::name_begin() const
{
    return (m_nameMap.begin());
}
 
inline CondAttrListCollection::name_const_iterator
CondAttrListCollection::name_end  () const
{
    return (m_nameMap.end());
}
    
inline CondAttrListCollection::name_size_type 
CondAttrListCollection::name_size() const
{
    return (m_nameMap.size());
}
 
inline CondAttrListCollection::ChanNum
CondAttrListCollection::chanNum(unsigned int index) const
{
    if (index < size()) {
        const_iterator it = begin();
        unsigned int count = index;
        while (count > 0) {
            ++it;
            --count;
        }
        return (it->first);
    }
    // otherwise return max
    else return (0xFFFF);
}
 
inline const CondAttrListCollection::AttributeList&
CondAttrListCollection::attributeList(ChanNum chanNum) const
{
    const_iterator itr=m_attrMap.find(chanNum);
    if (itr!=m_attrMap.end()) {
        return itr->second;
    } else {
        static const AttributeList attr;
        return attr;
    }
}
    
inline const IOVRange&         
CondAttrListCollection::iovRange(ChanNum chanNum) const
{
    iov_const_iterator itr=m_iovMap.find(chanNum);
    if (itr!=m_iovMap.end()) {
        return itr->second;
    } else {
        // Default is the minRange
        return (m_minRange);
    }
}
 
// find name for channel - empty string for unknonwn/unnamed channels
inline const std::string& CondAttrListCollection::chanName(ChanNum chanNum) const {
    name_const_iterator itr=m_nameMap.find(chanNum);
    if (itr!=m_nameMap.end()) {
        return itr->second;
    } else {
        static const std::string name;
        return name;
    }
}
 
inline const IOVRange&
CondAttrListCollection::minRange() const
{
    return (m_minRange);
}
 
inline bool
CondAttrListCollection::hasUniqueIOV() const
{
    return (m_hasUniqueIOV);
}
 
inline bool
CondAttrListCollection::add(ChanNum chanNum, const AttributeList& attributeList)
{
  if (m_attrMap.empty()) {
    m_spec=new coral::AttributeListSpecification();
    for (const auto& attr : attributeList) {
      const coral::AttributeSpecification& aspec=attr.specification();
      m_spec->extend(aspec.name(),aspec.typeName());
    }
  }
  m_attrMap[chanNum]=coral::AttributeList(*m_spec,true);
  m_attrMap[chanNum].fastCopyData(attributeList);
 
  return true;
}
 
inline void
CondAttrListCollection::addShared(ChanNum chanNum, const AttributeList& attributeList)
{
  if (m_attrMap.empty()) {
    m_spec=new coral::AttributeListSpecification();
    for (const auto& attr : attributeList) {
      const coral::AttributeSpecification& aspec=attr.specification();
      m_spec->extend(aspec.name(),aspec.typeName());
    }
  }
  m_attrMap[chanNum]=coral::AttributeList(*m_spec,true);
  m_attrMap[chanNum].merge(attributeList);
}
 
inline void                    
CondAttrListCollection::add(ChanNum chanNum, const IOVRange& range)
{
    m_iovMap[chanNum] = range;
 
    // Accumulate minRange
    IOVTime start = m_minRange.start();
    if (m_minRange.start() < range.start()) start = range.start();
    IOVTime stop = m_minRange.stop();
    if (range.stop() < m_minRange.stop()) stop = range.stop();
    m_minRange = IOVRange(start, stop);
    if (m_hasUniqueIOV && range != m_minRange)m_hasUniqueIOV = false;
}
 
inline void                    
CondAttrListCollection::add(ChanNum chanNum, const std::string& name)
{
    m_nameMap[chanNum] = name;
}
 
 
inline void                    
CondAttrListCollection::addNewStart(const IOVTime& start)
{
    if (start > m_minRange.start()) {
      m_minRange = IOVRange(start,m_minRange.stop());
    }
}
 
inline void                    
CondAttrListCollection::addNewStop(const IOVTime& stop)
{
    if (stop < m_minRange.stop()) {
    m_minRange = IOVRange(m_minRange.start(), stop);
    }
}
 
inline void
CondAttrListCollection::resetMinRange()
{
    // Reset minRange to max
    if (m_minRange.start().isTimestamp()) {
        m_minRange = IOVRange(IOVTime(IOVTime::MINTIMESTAMP), IOVTime(IOVTime::MAXTIMESTAMP));
    }
    else {
        m_minRange = IOVRange(IOVTime(IOVTime::MINRUN, IOVTime::MINEVENT), 
                              IOVTime(IOVTime::MAXRUN, IOVTime::MAXEVENT)); 
    }
    iov_const_iterator it1   = iov_begin();
    iov_const_iterator last1 = iov_end();
    for (; it1 != last1; ++it1) {
        const IOVTime& start = (*it1).second.start();
        const IOVTime& stop  = (*it1).second.stop();
        if (start > m_minRange.start() && stop < m_minRange.stop()) {
            m_minRange = IOVRange(start, stop);
        }
        else if (start > m_minRange.start()) {
            m_minRange = IOVRange(start,m_minRange.stop());
        }
        else if (stop < m_minRange.stop()) {
            m_minRange = IOVRange(m_minRange.start(), stop);
        }
    }
}
 
inline void
CondAttrListCollection::dump() const
{
    // min range
    std::cout << "min range: " << m_minRange << std::endl;
 
    // attribute list
    for (const auto& [chanNum, attrList] : m_attrMap) {
      std::cout << "chan, attr: " << chanNum << std::endl;
      attrList.toOutputStream(std::cout) << std::endl;
    }
    // IOVs
    for (const auto& [chanNum, iov] : m_iovMap) {
      std::cout << "chan, iov: " << chanNum << std::endl;
      std::cout << iov << std::endl;
    }
    // channel names
    for (const auto& [chanNum, name] : m_nameMap) {
      std::cout << "chan, name: " << chanNum << std::endl;
      std::cout << name << std::endl;
    }
 
}
 
inline void
CondAttrListCollection::dump(std::ostringstream& stream) const
{
  stream << m_minRange << " iov size " << m_iovMap.size() << std::endl;
  // IOVs
  for (const auto& [chanNum, iov] : m_iovMap) {
    stream << "chan, iov: " << chanNum << " " << iov << std::endl;
  }
  // Attribute list
  for (const auto& [chanNum, attrList] : m_attrMap) {
    stream << "chan, attr: " << chanNum << std::endl;
    attrList.toOutputStream(stream) << std::endl;
  }
  // channel names
  for (const auto& [chanNum, name] : m_nameMap) {
    stream << "chan, name: " << chanNum << " " << name << std::endl;
  }
}
 
 
inline
bool 
CondAttrListCollection::operator==( const CondAttrListCollection& rhs ) const
{
 
    // Compare minRange 
    if (m_minRange != rhs.m_minRange)                      return false;
    // Rest is in isSameButMinRange
    return (isSameButMinRange (rhs));
}
 
    
 
inline
bool
CondAttrListCollection::operator!=( const CondAttrListCollection& rhs ) const
{
    return (!((*this) == rhs));
}
 
inline
bool
CondAttrListCollection::isSameButMinRange ( const CondAttrListCollection& rhs,
                                            bool ignoreIOVs ) const
{
    
    // Compare with right hand side
 
    if(m_hasUniqueIOV != rhs.m_hasUniqueIOV)               return false;
    if(m_hasRunLumiBlockTime != rhs.m_hasRunLumiBlockTime) return false;
    if (m_attrMap.size() != rhs.m_attrMap.size())          return false;
    if (m_iovMap.size() != rhs.m_iovMap.size())            return false;
    if (m_nameMap.size() != rhs.m_nameMap.size())          return false;
 
    if (!ignoreIOVs) {
        // Check IOVs
        auto it1 = m_iovMap.begin();
        auto it2 = rhs.m_iovMap.begin();
        auto end1 = m_iovMap.end();
        for (; it1 != end1; ++it1, ++it2) {
            if (it1->first != it2->first) return false;
            if (it1->second != it2->second) return false;
        }
    }
 
    // Check attribute lists
    auto it3 = m_attrMap.begin();
    auto it4 = rhs.m_attrMap.begin();
    auto end3 = m_attrMap.end();
    for (; it3 != end3; ++it3, ++it4) {
        if (it3->first != it4->first) return false;
        if (it3->second != it4->second) return false;
    }
 
    // Check names
    auto it5 = m_nameMap.begin();
    auto it6 = rhs.m_nameMap.begin();
    auto end5 = m_nameMap.end();
    for (; it5 != end5; ++it5, ++it6) {
        if (it5->first != it6->first) return false;
        if (it5->second != it6->second) return false;
    }
 
    return true;
}
 
    
inline bool
    CondAttrListCollection::fixChanNum(const ChanNum oldChan,
                                       const ChanNum newChan) {
      auto attrRet = m_attrMap.emplace(newChan, m_attrMap[oldChan]);
      // if a new element was inserted, erase the old one
      if (attrRet.second) m_attrMap.erase(oldChan);
 
      auto iovRet = m_iovMap.emplace(newChan, m_iovMap[oldChan]);
      // if a new element was inserted, erase the old one
      if (iovRet.second) m_iovMap.erase(oldChan);
 
      auto nameRet = m_nameMap.emplace(newChan, m_nameMap[oldChan]);
      // if a new element was inserted, erase the old one
      if (nameRet.second) m_nameMap.erase(oldChan);
 
      return attrRet.first->first == newChan
          && iovRet.first->first == newChan
          && nameRet.first->first == newChan;
    }
    
    
 
#endif // DBDATAOBJECTS_CONDATTRLISTCOLLECTION_H