CaloCondBlobBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOCONDBLOBOBJS_CALOCONDBLOBBASE_H
#define CALOCONDBLOBOBJS_CALOCONDBLOBBASE_H

 
 
#include <stdint.h>
#include <vector>
#include <string>
#include <ostream>
#include <iostream>
#include "CoralBase/Blob.h"
#include "CaloCondBlobObjs/Exception.h"
#include "CaloCondBlobObjs/CaloCondType.h"
#include "CxxUtils/get_unaligned.h"
 
class CaloCondBlobBase{
 public:
  virtual ~CaloCondBlobBase();
  CaloCondBlobBase(const CaloCondBlobBase& other);
  CaloCondBlobBase& operator=(const CaloCondBlobBase& other);
  
  virtual uint16_t getType() const {return CaloCondType::BASE;}

  virtual void dump() const { dumpHeader(std::cout); } 
  virtual void dump(std::ostream& stm) const {dumpHeader(stm);} 
 
 
  //==================================================================
  //== Accessor methods for the header
  //==================================================================
  long     getBlobSize() const {return m_blob->size(); } 
  uint16_t getObjType() const;
  uint16_t getObjVersion() const; 
  uint32_t getObjSizeUint32() const; 
  uint32_t getObjSizeByte() const {return getObjSizeUint32()*sizeof(uint32_t);}
  uint32_t getNObjs() const;
  uint32_t getNChans() const;
  uint32_t getNGains() const;
  uint32_t getCommentSizeUint32() const;
  uint32_t getCommentSizeChar() const {return getCommentSizeUint32()*sizeof(uint32_t);}
  unsigned int getHdrSize() const {return 5;}
  
  //==================================================================
  //== Accessor methods for the comment fields
  //==================================================================
  std::string getAuthor() const;
  std::string getComment() const;
  uint64_t    getTimeStamp() const;
  std::string getDate() const; 
  std::string getFullComment() const;
 
 
  //==================================================================
  //== Blob field access
  //==================================================================
  const void* getAddress(unsigned int iEle) const;
  void* getAddress(unsigned int iEle);
  
  
 protected:
  CaloCondBlobBase(const coral::Blob& blob);

  CaloCondBlobBase(coral::Blob& blob);

  uint32_t createBlob(uint16_t objType,          
              uint16_t objVersion,
              uint32_t objSizeUint32, 
              uint32_t nObjs,
              uint32_t nChans,
              uint16_t nGains,
              const std::string& author="",
              const std::string& comment="",
              uint64_t timeStamp=0);

  void dumpHeader(std::ostream& stm) const; 
 
 private:
  CaloCondBlobBase(coral::Blob* blob_nc, const coral::Blob* blob);
 
  static uint32_t packGainAndNchans(const uint32_t gain, const uint32_t nChans);
  static uint32_t unpacknGains(const uint32_t gainAndnChans);
  static uint32_t unpacknChans(const uint32_t gainAndnChans);

  const uint32_t* getBlobStart() const;
  uint32_t* getBlobStart();

  coral::Blob*  m_blob_nc;

  const coral::Blob*  m_blob;

  bool          m_isBlobOwner;

  unsigned m_sizeOfObj;
  unsigned m_nChans;
  unsigned m_nGains;
protected:    
  const void* m_pDataStart;
};
 
 
//
//_________________________________________________________
inline const uint32_t*
CaloCondBlobBase::getBlobStart() const
{
  return static_cast<const uint32_t*>(m_blob->startingAddress());
}
 
//
//_________________________________________________________
inline uint32_t*
CaloCondBlobBase::getBlobStart() 
{
  return static_cast<uint32_t*>(m_blob_nc->startingAddress());
}
 
//
//_________________________________________________________
inline uint16_t 
CaloCondBlobBase::getObjType() const 
{
  if(uint64_t(m_blob->size())<getHdrSize()*sizeof(uint32_t)) 
    throw CaloCond::InvalidBlob("CaloCondBlobBase::getObjType");
  return static_cast<const uint16_t*>(m_blob->startingAddress())[0];
}
 
//
//_________________________________________________________
inline uint16_t 
CaloCondBlobBase::getObjVersion() const 
{
  if(uint64_t(m_blob->size())<getHdrSize()*sizeof(uint32_t)) 
    throw CaloCond::InvalidBlob("CaloCondBlobBase::getObjVersion");
  return static_cast<const uint16_t*>(m_blob->startingAddress())[1];
}
 
//
//_________________________________________________________
inline uint32_t 
CaloCondBlobBase::getObjSizeUint32() const 
{
  return m_sizeOfObj;
}
 
//
//_________________________________________________________
inline uint32_t 
CaloCondBlobBase::getNObjs() const 
{
  if(uint64_t(m_blob->size())<getHdrSize()*sizeof(uint32_t)) 
    throw CaloCond::InvalidBlob("CaloCondBlobBase::getNObjs");
  return static_cast<const uint32_t*>(m_blob->startingAddress())[2];
}
 
//
//_________________________________________________________
inline uint32_t 
CaloCondBlobBase::getNChans() const 
{
  return m_nChans;
}
 
//
//_________________________________________________________
inline uint32_t 
CaloCondBlobBase::getNGains() const 
{
  return m_nGains;
 
 
}
 
//
//_________________________________________________________
inline uint32_t 
CaloCondBlobBase::getCommentSizeUint32() const 
{
  if(uint64_t(m_blob->size())<getHdrSize()*sizeof(uint32_t)) 
    throw CaloCond::InvalidBlob("CaloCondBlobBase::getCommentSizeUint32");
  return static_cast<const uint32_t*>(m_blob->startingAddress())[4];
}
 
//
//_________________________________________________________
inline const void* 
CaloCondBlobBase::getAddress(unsigned int iEle) const
{
  if(iEle>=getNObjs()){ 
    throw CaloCond::IndexOutOfRange("CaloCondBlobBase::getAddress", iEle, getNObjs());
  }
  return static_cast<const void*>
    ( getBlobStart() + getHdrSize() + getObjSizeUint32()*iEle );
}
 
//
//_________________________________________________________
inline void* 
CaloCondBlobBase::getAddress(unsigned int iEle) 
{
  if(iEle>=getNObjs()){ 
    throw CaloCond::IndexOutOfRange("CaloCondBlobBase::getAddress", iEle, getNObjs());
  }
  return static_cast<void*>
    ( getBlobStart() + getHdrSize() + getObjSizeUint32()*iEle );
}
 
//
//_________________________________________________________
inline uint64_t 
CaloCondBlobBase::getTimeStamp() const 
{
  if(!getCommentSizeUint32()) return 0;
  auto p = reinterpret_cast<const uint8_t*>(getBlobStart()+getHdrSize() +
                                            getNObjs()*getObjSizeUint32());
  return CxxUtils::get_unaligned64 (p);
}
 
#endif