IOVDbNamespace Namespace Reference

Classes
class	Cool2Json
class	FMDReadLock
class	IovStore
class	ReadFromFileMetaData
class	SafeReadFromFileMetaData

Enumerations
enum	FolderType {   UNKNOWN =-1 , AttrList =0 , AttrListColl , PoolRef ,   PoolRefColl , CoraCool , CoolVector , JSON ,   NUM_FOLDER_TYPES }

Functions
std::string	base64Encode (const coral::Blob &blob)
coral::Blob	base64Decode (const std::string &base64String)
std::ostream &	operator<< (std::ostream &o, const Cool2Json &c)
FolderType	determineFolderType (const std::string &folderDescription, const std::string &spec, const std::vector< cool::ChannelId > &chans)
	Determine folder type with optional check using clid service to check clid matches typename.
FolderType	determineFolderType (const cool::IFolderPtr &pFolder, IClassIDSvc *clidsvc=nullptr)
	Determine folder type with optional check using clid service to check clid matches typename.
FolderType	determineFolderType (const CondAttrListCollection *pAttrListColl)
	Determine folder type using the CondAttrListCollection pointer.
FolderType	determineFolderType (const CondAttrListCollection &pAttrListColl)
	Determine folder typeusing the CondAttrListCollection reference.
FolderType	determineFolderType (const coral::AttributeSpecification &spec)
	Determine folder type using the coral::AttributeSpecification.
bool	poolCompatible (const cool::IRecordSpecification &rspec)
	Is the folder type compatible with Pool storage type?
bool	poolCompatible (const std::string &specString)
bool	poolCompatible (const CondAttrListCollection *pAttrListColl)
bool	poolCompatible (const CondAttrListCollection &attrListColl)
std::string	folderTypeName (const FolderType f)
	Give a string name for the folder type.
const coral::AttributeListSpecification &	attrList2Spec (const coral::AttributeList &atrlist)
	return the AttributeListSpecification of an AttributeList
unsigned int	attributeSize (const coral::Attribute &attribute)
	return the size (in bytes) of an Attribute
bool	typeSizeIsKnown (const coral::Attribute &attribute)
	Return a bool indicating whether the size of a given Attribute can be determined.
unsigned int	attributeListSize (const coral::AttributeList &atrlist)
	return the size (in bytes) of an AttributeList
int	countSelectedChannels (const std::vector< cool::ChannelId > &channels, const cool::ChannelSelection &selected)
	Count the number of selected channels in a vector of channels according to cool::Channel selection.
IOVTime	makeEpochOrRunLumi (const cool::ValidityKey key, const bool timeIsEpoch)
	Create an IOVTime in ns of epoch or run-lumi (determined by the bool) from a ValidityKey.
unsigned long long	iovTimeFromSeconds (const unsigned long long seconds)
	Create a long long time in ns from s.
unsigned long long	iovTimeFromRunLumi (const unsigned long long run, const unsigned long long lumi=0)
	Create a long long representing the IOV from run, lumi.
std::pair< unsigned long long, unsigned long long >	runLumiFromIovTime (const unsigned long long iovTime)
	Return a [run,lumi] pair from an IOV time.
IOVRange	makeRange (const cool::ValidityKey since, const cool::ValidityKey until, const bool timeIsEpoch)
	Make an IOVRange from two validity keys.
cool::ChannelId	makeChannel (const std::string &strval, const cool::ChannelId defchan)
	Create a ChannelId from a string; if string is empty, return the default channel number given.
std::pair< bool, std::string >	folderMetadata (IOVDbConn *pConnection, const std::string &folderName)
	Retrieve (bool) multiversion flag and folder description.
std::pair< std::vector< cool::ChannelId >, std::vector< std::string > >	channelList (IOVDbConn *pConnection, const std::string &folderName, const bool named=false)
	Retrieve channel information.
template<class NumericType>
bool	inRange (const NumericType &val, const std::pair< NumericType, NumericType > &range)
	Function to check whether a number is in the inclusive range, given as a pair.
template<class NumericType>
bool	inRange (const NumericType &val, const std::vector< std::pair< NumericType, NumericType > > &ranges)
std::string	jsonAttribute (const coral::Attribute &)
	Produce a representation of a coral::Attribute as a json string.
std::string	jsonAttributeList (const coral::AttributeList &)
	Produce a representation of a coral::AttributeList as a json string.
std::string	spaceStrip (const std::string &input)
	Trim leading and trailing spaces,return a new trimmed string.
int	makeChannel (const std::string &strval, const int defchan)
	Produce a channel number from the string; default to 'defchan' if empty.
unsigned long long	iovFromTimeString (const std::string &iovString)
	Take a string integer giving a time in seconds and convert it to a ULL in nanoseconds.
unsigned long long	iovFromRunString (const std::string &runString)
	Take a string run number and convert it to an ULL representing run<<32.
unsigned long long	iovFromLumiBlockString (const std::string &lbString)
	String representation of lumiblock just converted to LL (as in original code) and returned as a ULL.
std::string	sanitiseJsonString (const std::string &dataString)
	Sanitise json string, escaping raw carriage returns.
int	parseClid (const std::string &addrHeaderStr)
	Extract the Class ID (an integer) from a string of form <addrHeader><address_header service_type="256" clid="12345" ></addrHeader>
std::string	parseTypename (const std::string &description)
	Extract the typename from a folder description.
std::string	deleteRegex (const std::string &original, const std::string &regex)
	Delete characters of a matching regex from the input string.
std::string	quote (const std::string &sentence)
	Enclose a string in ".
std::string	unescapeQuotes (const std::string &original)
std::string	unescapeBackslash (const std::string &original)
std::string	sanitiseFilename (const std::string &fname)
	Replace the '/' of a file path with '^'.
std::string	sanitiseCrestTag (const std::string &fname)
	return valid CREST tag name from folder name
std::string	replaceNULL (const std::string &possibleNULL)
	replace an uppercase NULL (such as returned by oracle) in string with a lowercase null (such as used in JSON)
std::string	sanitiseXml (const std::string &pseudoXmlString)
	for use when converting cool folder description JSON
bool	looksLikeMagicTag (const std::string &candidateTag)
	Looks like it should be magic.
bool	tagIsMagic (const std::string &candidateTag)
	Resolve magic tag.
std::vector< std::string >	parseMagicTag (const std::string &candidateTag)
	Takes a tag of form TagInfo{Major|Minor}/<tag> or TagInfo{Major|Minor}/<prefix>/<tag> and resolve it to a string vector{"Major|Minor", <prefix>, <tag>} returns an empty vector if a match is not found.
std::vector< std::string >	parseLinkNames (const std::string &linktext)
	Parse string of format "A:X::B:C" to "A" , "X::B", "C".
std::pair< std::string, std::string >	tag2PrefixTarget (const std::vector< std::string > &parseResult)
	Takes a vector<string> containing {"<fulltag>", "Major|Minor", "<prefix>", "<tag>"} and returns a pair of {"<prefix>", "<tag>"}.
bool	replaceServiceType71 (std::string &addrHeader)
template<class IntType>
std::vector< std::pair< IntType, IntType > >	parseChannelSpec (const std::string &chanspecString)
	Parse a channel specification string of the format ":3, 65:67,100:120, 130: " into a vector of pairs.
std::string	getTagInfo (const std::string &tag, const ITagInfoMgr *tagInfoMgr)
	Retrieve the TagInfo.
std::string	getGeoAtlasVersion ()
	Get the GeoAtlas version directly from GeoModelSvc.
std::optional< bool >	checkTagLock (const cool::IFolderPtr &fptr, const std::string &tag)
	Check whether a tag is locked on a folder, if possible.
std::string	resolveUsingTagInfo (const std::string &tag, const ITagInfoMgr *tagInfoMgr)

Variables
constexpr unsigned long long	ALL_LUMI_BLOCKS {0xFFFFFFFF}
	All the lumi blocks in one run.
static const std::string	s_openJson = "{"
	json open tag, '{'
static const std::string	s_closeJson = "}"
	json close tag, '}'
static const std::string	s_delimiterJson = ", "
	json standard delimiter ', '

Enumeration Type Documentation

FolderType

enum IOVDbNamespace::FolderType

Enumerator
UNKNOWN
AttrList
AttrListColl
PoolRef
PoolRefColl
CoraCool
CoolVector
JSON
NUM_FOLDER_TYPES

Definition at line 26 of file FolderTypes.h.

                  {
    UNKNOWN=-1,
    AttrList=0,
    AttrListColl,
    PoolRef,
    PoolRefColl,
    CoraCool,
    CoolVector,
    JSON,
    NUM_FOLDER_TYPES
   };

Function Documentation

attributeListSize()

unsigned int IOVDbNamespace::attributeListSize

(

const coral::AttributeList &

atrlist

)

return the size (in bytes) of an AttributeList

Definition at line 72 of file IOVDbCoolFunctions.cxx.

                                                      {
    unsigned int total{};
    for (const auto & attribute:atrlist){
      total+=IOVDbNamespace::attributeSize(attribute);
    }
    return total;  
  }

attributeSize()

unsigned int IOVDbNamespace::attributeSize

(

const coral::Attribute &

attribute

)

return the size (in bytes) of an Attribute

Definition at line 57 of file IOVDbCoolFunctions.cxx.

                                                 {
    const auto & spec{attribute.specification()};
    try{
      return sizeFunctions.at(std::type_index(spec.type()))(attribute);
    }catch (const std::out_of_range& oor) {
      return 0;
    }
  }

attrList2Spec()

const coral::AttributeListSpecification & IOVDbNamespace::attrList2Spec

(

const coral::AttributeList &

atrlist

)

return the AttributeListSpecification of an AttributeList

Definition at line 52 of file IOVDbCoolFunctions.cxx.

                                                  {
    return atrlist.specification();
  }

base64Decode()

coral::Blob IOVDbNamespace::base64Decode

(

const std::string &

base64String

)

Definition at line 26 of file Base64Codec.cxx.

                                              {
    const auto &charVec = CxxUtils::base64_decode(base64String);
    coral::Blob blob(charVec.size());
    memcpy(blob.startingAddress(), charVec.data(), charVec.size());
    return blob;
  }

base64Encode()

std::string IOVDbNamespace::base64Encode

(

const coral::Blob &

blob

)

Definition at line 18 of file Base64Codec.cxx.

                                      {
    //Blob::startingAddress returns a const void *, so cast to byte size
    const auto *const address = static_cast<const unsigned char *>(blob.startingAddress());
    const unsigned int nBytes = blob.size();
    return CxxUtils::base64_encode(address, nBytes);
  }

channelList()

std::pair< std::vector< cool::ChannelId >, std::vector< std::string > > IOVDbNamespace::channelList	(	IOVDbConn *	pConnection,
		const std::string &	folderName,
		const bool	named )

Retrieve channel information.

Definition at line 160 of file IOVDbCoolFunctions.cxx.

                                                                                      {
    std::vector<cool::ChannelId> channelNumbers;
    std::vector<std::string> channelNames;
    //
    cool::IDatabasePtr dbPtr=pConnection->getCoolDb();
    // get folder and read information
    if (!dbPtr->existsFolder(folderName)) {
      throw std::runtime_error( "Folder " + folderName + " does not exist" );
    }
    cool::IFolderPtr fldPtr=dbPtr->getFolder(folderName);
    if (named) {
      typedef std::map<cool::ChannelId,std::string> ChanMap_t;
      const ChanMap_t & chanmap=fldPtr->listChannelsWithNames();
      channelNumbers.reserve(chanmap.size());
      channelNames.reserve(chanmap.size());
      auto unzipElement = [&](const ChanMap_t::value_type & element){
        channelNumbers.push_back(element.first);
        channelNames.push_back(element.second);
      };
      std::for_each(chanmap.begin(), chanmap.end(),unzipElement);
    } else {
      channelNumbers=fldPtr->listChannels();
    }
    return std::make_pair(std::move(channelNumbers), std::move(channelNames));
  }

checkTagLock()

std::optional< bool > IOVDbNamespace::checkTagLock	(	const cool::IFolderPtr &	fptr,
		const std::string &	tag )

Check whether a tag is locked on a folder, if possible.

Definition at line 43 of file TagFunctions.cxx.

                                                                 {
    try {
      return (fptr->tagLockStatus(tag)==cool::HvsTagLock::LOCKED); 
    } catch (cool::Exception& e) {
      //dont do anything, but...
    }
    //...return a null object
    return std::nullopt;
  }

countSelectedChannels()

int IOVDbNamespace::countSelectedChannels	(	const std::vector< cool::ChannelId > &	channels,
		const cool::ChannelSelection &	selected )

Count the number of selected channels in a vector of channels according to cool::Channel selection.

Definition at line 81 of file IOVDbCoolFunctions.cxx.

                                                                                                         {
    auto isSelected = [& selected](cool::ChannelId id){return selected.inSelection(id);};
    return std::count_if(channels.begin(), channels.end(),isSelected);//return type of count_if is signed
  }

deleteRegex()

std::string IOVDbNamespace::deleteRegex	(	const std::string &	original,
		const std::string &	regex )

Delete characters of a matching regex from the input string.

Definition at line 79 of file IOVDbStringFunctions.cxx.

                                                                  {
    const std::regex delre(regex);
    return std::regex_replace(original,delre,"");
  }

determineFolderType() [1/5]

FolderType IOVDbNamespace::determineFolderType

(

const CondAttrListCollection &

attrListColl

)

Determine folder typeusing the CondAttrListCollection reference.

Definition at line 74 of file FolderTypes.cxx.

                                                                   {
     FolderType ftype(AttrList);
     //has a single magic channel?
     if (attrListColl.size()==1 && attrListColl.begin()->first==0xFFFF) {
       if (poolCompatible (attrListColl)) return PoolRef;
       return AttrList;
     } else {
       ftype=AttrListColl;
       if ( attrListColl.size()>0) {
         if (poolCompatible(attrListColl)) return PoolRefColl;
       }
     }
     return ftype;
   }

determineFolderType() [2/5]

FolderType IOVDbNamespace::determineFolderType

(

const CondAttrListCollection *

pAttrListColl

)

Determine folder type using the CondAttrListCollection pointer.

Definition at line 57 of file FolderTypes.cxx.

                                                                    {
     FolderType ftype(AttrList);
     //has a single magic channel?
     if (pAttrListColl->size()==1 && pAttrListColl->begin()->first==0xFFFF) {
       if (poolCompatible (pAttrListColl)) return PoolRef;
       return AttrList;
     } else {
       ftype=AttrListColl;
       if ( pAttrListColl->size()>0) {
         if (poolCompatible(pAttrListColl)) return PoolRefColl;
       }
     }
     return ftype;
   }

determineFolderType() [3/5]

FolderType IOVDbNamespace::determineFolderType	(	const cool::IFolderPtr &	pFolder,
		IClassIDSvc *	)

Determine folder type with optional check using clid service to check clid matches typename.

Definition at line 36 of file FolderTypes.cxx.

                                                                     {
    const auto & folderDescription = pFolder->description();
    //If you find a coracool tag, it is unambiguously a coracool folder
    if (folderDescription.find("<coracool>") != std::string::npos) return CoraCool;
    const std::string typeName = parseTypename(folderDescription);
    //if the type is CondAttrListVec, and yet it is not a CoraCool, it must be a CoolVector
    if (typeName=="CondAttrListVec") return CoolVector;
    //check if the payload spec is compatible with a pool ref/pool ref collection
    if (poolCompatible(pFolder->payloadSpecification())){
      const auto & chans=pFolder->listChannels();
      const auto nchans = chans.size();
      const bool onlyOneSpecialChannel = ((nchans == 1) and (chans[0] == 0));
      return onlyOneSpecialChannel ? PoolRef : PoolRefColl;
    }
    if (typeName == "CondAttrListCollection") return AttrListColl;
    //defaults to AttrList
    return AttrList;
   }

determineFolderType() [4/5]

FolderType IOVDbNamespace::determineFolderType

(

const coral::AttributeSpecification &

spec

)

Determine folder type using the coral::AttributeSpecification.

Definition at line 90 of file FolderTypes.cxx.

                                                               {
     FolderType result(UNKNOWN);
     if (spec.name()=="PoolRef" && spec.typeName()=="string") result = PoolRef;
     return result;
   }

determineFolderType() [5/5]

FolderType IOVDbNamespace::determineFolderType	(	const std::string &	folderDescription,
		const std::string &	spec,
		const std::vector< cool::ChannelId > &	chans )

Determine folder type with optional check using clid service to check clid matches typename.

Definition at line 17 of file FolderTypes.cxx.

                                                                                                                          {
    //If you find a coracool tag, it is unambiguously a coracool folder
    if (folderDescription.find("<coracool>") != std::string::npos) return CoraCool;
    const std::string typeName = parseTypename(folderDescription);
    //if the type is CondAttrListVec, and yet it is not a CoraCool, it must be a CoolVector
    if (typeName=="CondAttrListVec") return CoolVector;
    //check if the payload spec is compatible with a pool ref/pool ref collection
    if (poolCompatible(spec)){
      const auto nchans = chans.size();
      const bool onlyOneSpecialChannel = ((nchans == 1) and (chans[0] == 0));
      return onlyOneSpecialChannel ? PoolRef : PoolRefColl;
    }
    if (typeName == "CondAttrListCollection") return AttrListColl;
    //defaults to AttrList
    return AttrList;
   }

folderMetadata()

std::pair< bool, std::string > IOVDbNamespace::folderMetadata	(	IOVDbConn *	pConnection,
		const std::string &	folderName )

Retrieve (bool) multiversion flag and folder description.

Definition at line 136 of file IOVDbCoolFunctions.cxx.

                                                                       {
    bool multiversion{};
    std::string folderdesc{};
    // folder being read from COOL
    // get COOL database - will wake up connection on first access
    cool::IDatabasePtr dbPtr=pConnection->getCoolDb();
    if (not dbPtr.get()) {
      throw std::runtime_error( "Conditions database connection " + pConnection->name() + " cannot be opened - STOP" );
    }
    // get folder and read information
    if (!dbPtr->existsFolder(folderName)) {
      throw std::runtime_error( "Folder " + folderName + " does not exist" );
    }
    cool::IFolderPtr fldPtr=dbPtr->getFolder(folderName);
    // get versiontype of folder
    multiversion=(fldPtr->versioningMode()==cool::FolderVersioning::MULTI_VERSION);
    // read and process description string
    folderdesc=fldPtr->description();
    return std::make_pair(multiversion, std::move(folderdesc));
  }

folderTypeName()

std::string IOVDbNamespace::folderTypeName

(

const FolderType

f

)

Give a string name for the folder type.

Definition at line 135 of file FolderTypes.cxx.

                                     {
      static const std::vector<std::string> names{"AttrList", "AttrListColl", "PoolRef",
      "PoolRefColl", "CoraCool", "CoolVector", "JSON"};
      if (f==UNKNOWN) return "Unknown";
      return names[f];
   }

getGeoAtlasVersion()

std::string IOVDbNamespace::getGeoAtlasVersion

(

)

Get the GeoAtlas version directly from GeoModelSvc.

Definition at line 33 of file TagFunctions.cxx.

                      {
    SmartIF<IGeoModelSvc> geomodel{Gaudi::svcLocator()->service("GeoModelSvc")};
    if (not geomodel) {
      throw std::runtime_error("The GeoModelSvc could not be retrieved in TagFunctions.cxx getGeoAtlasVersion()");
    } else { 
      return geomodel->atlasVersion();
    }
  }

getTagInfo()

std::string IOVDbNamespace::getTagInfo	(	const std::string &	tag,
		const ITagInfoMgr *	tagInfoMgr )

Retrieve the TagInfo.

Definition at line 21 of file TagFunctions.cxx.

                                                                 {
    std::string result{};
    enum ResultIndices{WHOLETAG, MAJMIN, PATH1, PATH2, SIZEWITHPREFIX};
    auto results=IOVDbNamespace::parseMagicTag(tag);
    if (results.empty()) return result;
    const auto & [prefix, target] = IOVDbNamespace::tag2PrefixTarget(results);
    std::string tagval = tagInfoMgr->findTag(target);
    if (not tagval.empty()) result=prefix+tagval;
    return result;
  }

inRange() [1/2]

template<class NumericType>

bool IOVDbNamespace::inRange	(	const NumericType &	val,
		const std::pair< NumericType, NumericType > &	range )

Function to check whether a number is in the inclusive range, given as a pair.

Typically used with Channel ranges for COOL

Definition at line 42 of file IOVDbCoolFunctions.h.

                                                                                   {
    return (val>=range.first && val<=range.second);
  }

inRange() [2/2]

template<class NumericType>

bool IOVDbNamespace::inRange	(	const NumericType &	val,
		const std::vector< std::pair< NumericType, NumericType > > &	ranges )

Definition at line 48 of file IOVDbCoolFunctions.h.

                                                                                                {
    auto valueInRange=[val](const std::pair<NumericType, NumericType> & range){ return inRange(val,range); };
    return std::any_of(ranges.begin(), ranges.end(), valueInRange);
  }

iovFromLumiBlockString()

unsigned long long IOVDbNamespace::iovFromLumiBlockString

(

const std::string &

lbString

)

String representation of lumiblock just converted to LL (as in original code) and returned as a ULL.

Definition at line 45 of file IOVDbStringFunctions.cxx.

                                                    {
    if (lbString.empty()) return 0LL;
    unsigned long long lb=std::stoll(lbString.c_str());
    return lb;
  }

iovFromRunString()

unsigned long long IOVDbNamespace::iovFromRunString

(

const std::string &

runString

)

Take a string run number and convert it to an ULL representing run<<32.

Definition at line 38 of file IOVDbStringFunctions.cxx.

                                               {
    if (runString.empty()) return 0LL;
    unsigned long long run=std::stoi(runString);
    return run<<32LL;
  }

iovFromTimeString()

unsigned long long IOVDbNamespace::iovFromTimeString

(

const std::string &

iovString

)

Take a string integer giving a time in seconds and convert it to a ULL in nanoseconds.

Definition at line 31 of file IOVDbStringFunctions.cxx.

                                                {
    if (iovString.empty()) return 0LL;
    unsigned long long time=std::stoi(iovString);
    return time*1000000000LL;
  }

iovTimeFromRunLumi()

unsigned long long IOVDbNamespace::iovTimeFromRunLumi	(	const unsigned long long	run,
		const unsigned long long	lumi )

Create a long long representing the IOV from run, lumi.

Definition at line 103 of file IOVDbCoolFunctions.cxx.

                                                                                 {
    return (run<<32) + lumi;
  }

iovTimeFromSeconds()

unsigned long long IOVDbNamespace::iovTimeFromSeconds

(

const unsigned long long

seconds

)

Create a long long time in ns from s.

Definition at line 98 of file IOVDbCoolFunctions.cxx.

                                                      {
    return seconds*1000000000LL;
  }

jsonAttribute()

std::string IOVDbNamespace::jsonAttribute

(

const coral::Attribute &

attr

)

Produce a representation of a coral::Attribute as a json string.

Definition at line 15 of file IOVDbJsonStringFunctions.cxx.

                                            {
    std::ostringstream os;
    attr.toOutputStream(os);
    const std::string native=os.str();
    const bool stringPayload=(native.find(" (string) ") != std::string::npos);
    const bool blobPayload=(native.find(" (blob) ") != std::string::npos);
    const std::string sep(" : ");
    const auto separatorPosition = native.find(sep);
    const std::string payloadOnly=native.substr(separatorPosition+3);
    if (stringPayload) return quote(sanitiseJsonString(payloadOnly));
    if (blobPayload){
      return quote(IOVDbNamespace::base64Encode(attr.data<coral::Blob>()));
    }
    if (payloadOnly == "NULL") {
      return "null";
    }
    return payloadOnly;
  }

jsonAttributeList()

std::string IOVDbNamespace::jsonAttributeList

(

const coral::AttributeList &

atrlist

)

Produce a representation of a coral::AttributeList as a json string.

Definition at line 35 of file IOVDbJsonStringFunctions.cxx.

                                                      {
    std::string os("[");
    const unsigned int nelement=atrlist.size();
    std::string delimiter(" ");
    for (unsigned int i(0);i!=nelement;++i){
      if (i==1) delimiter = s_delimiterJson;
      os+=delimiter;
      os+=jsonAttribute(atrlist[i]);
    }
    os+="]";
    return os;
  }

looksLikeMagicTag()

bool IOVDbNamespace::looksLikeMagicTag

(

const std::string &

candidateTag

)

Looks like it should be magic.

Definition at line 150 of file IOVDbStringFunctions.cxx.

                                                   {
    return (candidateTag.compare(0,7, "TagInfo")==0 and
      candidateTag.find('/')!=std::string::npos);
  }

makeChannel() [1/2]

cool::ChannelId IOVDbNamespace::makeChannel	(	const std::string &	strval,
		const cool::ChannelId	defchan )

Create a ChannelId from a string; if string is empty, return the default channel number given.

Definition at line 128 of file IOVDbCoolFunctions.cxx.

                                                                    {
    // construct a cool channelId from the string value (numeric)
    // if empty, use the default value
    if (not strval.empty()) return std::stol(strval);
    return defchan;
  }

makeChannel() [2/2]

int IOVDbNamespace::makeChannel	(	const std::string &	strval,
		const int	defchan )

Produce a channel number from the string; default to 'defchan' if empty.

Definition at line 23 of file IOVDbStringFunctions.cxx.

                                                          {
    // construct a cool channelId from the string value (numeric)
    // if empty, use the default value
    if (!strval.empty()) return std::stoi(strval);
    return defchan;
  }

makeEpochOrRunLumi()

IOVTime IOVDbNamespace::makeEpochOrRunLumi	(	const cool::ValidityKey	key,
		const bool	timeIsEpoch )

Create an IOVTime in ns of epoch or run-lumi (determined by the bool) from a ValidityKey.

Definition at line 87 of file IOVDbCoolFunctions.cxx.

                                                                       {
    IOVTime time;
    if(timeIsEpoch){
      time.setTimestamp(key);
    } else {
      time.setRETime(key);
    }
    return time;
  }

makeRange()

IOVRange IOVDbNamespace::makeRange	(	const cool::ValidityKey	since,
		const cool::ValidityKey	until,
		const bool	timeIsEpoch )

Make an IOVRange from two validity keys.

Definition at line 113 of file IOVDbCoolFunctions.cxx.

                                                                                            {
    // make an IOVRange object corresponding to given interval
    // dealing with timestamp/RunLB differences
    IOVTime itsince,ituntil;
    if (timeIsEpoch) {
      itsince.setTimestamp(since);
      ituntil.setTimestamp(until);
    } else {
      itsince.setRETime(since);
      ituntil.setRETime(until);
    }
    return IOVRange(itsince,ituntil);
  }

operator<<()

std::ostream & IOVDbNamespace::operator<<	(	std::ostream &	o,
		const Cool2Json &	c )

Definition at line 202 of file Cool2Json.cxx.

                                                           {
    o << c.description() << std::endl;
    return o;
  }

parseChannelSpec()

template<class IntType>

std::vector< std::pair< IntType, IntType > > IOVDbNamespace::parseChannelSpec

(

const std::string &

chanspecString

)

Parse a channel specification string of the format ":3, 65:67,100:120, 130: " into a vector of pairs.

Definition at line 34 of file IOVDbStringFunctions.h.

                                                    {
    typedef std::pair<IntType, IntType> ChanRange;
    const auto defaults=ChanRange(0,std::numeric_limits<IntType>::max());
    //
    std::vector<ChanRange> result;
    std::string::size_type index;
    std::string rangespec, chanspec(chanspecString);
    bool first=true;
    do {
        index=chanspec.find(',');
        if (index!=std::string::npos) {
            rangespec=chanspec.substr(0,index);
            chanspec=chanspec.substr(index+1,chanspec.size());
        } else {
            rangespec=chanspec;
        }
        if (!rangespec.empty()) {
            // parse the range specification, look for : separator between limits
            std::string::size_type icol=rangespec.find(':');
            int lower,upper;
            if (icol!=std::string::npos) {
                lower=makeChannel(spaceStrip(rangespec.substr(0,icol)),defaults.first);
                upper=makeChannel(spaceStrip(rangespec.substr(icol+1,rangespec.size())),defaults.second);
            } else {
                lower=atol(spaceStrip(rangespec).c_str());
                upper=lower;
            }
            if (first) {
                first=false;
            } 
            result.push_back(ChanRange(lower,upper));
        }
    } while (index!=std::string::npos);
    return result;
  }

parseClid()

int IOVDbNamespace::parseClid

(

const std::string &

addrHeaderStr

)

Extract the Class ID (an integer) from a string of form <addrHeader><address_header service_type="256" clid="12345" ></addrHeader>

Definition at line 59 of file IOVDbStringFunctions.cxx.

                                            {
    //string of form
    //<addrHeader><address_header service_type="256" clid="12345" /></addrHeader>
    std::string regex=R"delim(clid\s*=\s*"([0-9]*)")delim";
    std::regex re(regex);
    std::smatch clidMatch;
    bool match=std::regex_search(addrHeaderStr, clidMatch,re);
    return (match) ? std::stoi(clidMatch[1]) : -1;
  }

parseLinkNames()

std::vector< std::string > IOVDbNamespace::parseLinkNames

(

const std::string &

linktext

)

Parse string of format "A:X::B:C" to "A" , "X::B", "C".

Definition at line 177 of file IOVDbStringFunctions.cxx.

                                           {
    std::vector<std::string> v{};
    if (linktext.empty()) return v;
    //regex:
    //(anything except colon, multiple times) then _possibly_ (two colons and string of anything except colons)
    // anything except colon) then (colon or end-of-line)
    const std::string linkRegexStr{"([^:]*(::[^:]*)?)(:|$)"};
    std::regex linkMatchSpec(linkRegexStr);
    //give a token iterator using the regex and returning the first substring (i.e. the
    //bit before a single colon or line end, which would be for example "ALink" or "MyContext::AnotherLink" )
    std::sregex_token_iterator pos(linktext.cbegin(), linktext.cend(),linkMatchSpec,{1});
    std::sregex_token_iterator e;
    for (;pos!=e;++pos)  {
      // the resulting text _should not_ contain spaces, but strip it to be sure.
      if (not pos->str().empty()) v.push_back(spaceStrip(pos->str()));
    }
    return v;
  }

parseMagicTag()

std::vector< std::string > IOVDbNamespace::parseMagicTag

(

const std::string &

v

)

Takes a tag of form TagInfo{Major|Minor}/<tag> or TagInfo{Major|Minor}/<prefix>/<tag> and resolve it to a string vector{"Major|Minor", <prefix>, <tag>} returns an empty vector if a match is not found.

Definition at line 163 of file IOVDbStringFunctions.cxx.

                                    {
    std::vector<std::string> result;
    std::string regex7=R"delim(TagInfo(Major|Minor)/([^/]*)/?([^/]*)?)delim";
    std::regex matchmagic(regex7);
    std::smatch x;
    bool foundmagic=std::regex_match(v,x,matchmagic);
    if (foundmagic){
      for (const auto & i:x)
      if (i!="") result.push_back(i);
    }
    return result;
  }

parseTypename()

std::string IOVDbNamespace::parseTypename

(

const std::string &

description

)

Extract the typename from a folder description.

Definition at line 70 of file IOVDbStringFunctions.cxx.

                                              {
    std::string regex=R"delim(<typeName>\s*([^\s]+)\s*</typeName>)delim";
    std::regex re(regex);
    std::smatch typeMatch;
    bool match=std::regex_search(description, typeMatch,re);
    return (match) ? std::string(typeMatch[1]) : std::string("");
  }

poolCompatible() [1/4]

bool IOVDbNamespace::poolCompatible

(

const CondAttrListCollection &

attrListColl

)

Definition at line 128 of file FolderTypes.cxx.

                                                              {
     const coral::AttributeList& payload1=attrListColl.begin()->second;
     const coral::AttributeSpecification& spec=payload1[0].specification();
     return (spec.name()=="PoolRef" && spec.typeName()=="string");
   }

poolCompatible() [2/4]

bool IOVDbNamespace::poolCompatible

(

const CondAttrListCollection *

pAttrListColl

)

Definition at line 121 of file FolderTypes.cxx.

                                                               {
     const coral::AttributeList& payload1=pAttrListColl->begin()->second;
     const coral::AttributeSpecification& spec=payload1[0].specification();
     return (spec.name()=="PoolRef" && spec.typeName()=="string");
   }

poolCompatible() [3/4]

bool IOVDbNamespace::poolCompatible

(

const cool::IRecordSpecification &

rspec

)

Is the folder type compatible with Pool storage type?

Definition at line 97 of file FolderTypes.cxx.

                                                        {
     return (rspec.exists("PoolRef") && rspec[0].name()=="PoolRef" &&
      rspec[0].storageType()==cool::StorageType::String4k);
   }

poolCompatible() [4/4]

bool IOVDbNamespace::poolCompatible

(

const std::string &

specString

)

Definition at line 103 of file FolderTypes.cxx.

                                               {
     nlohmann::json js = nlohmann::json::parse(specString);
     if(js.is_array()){
       int n = js.size();
       for (int i = 0; i <= n; i++) {
         nlohmann::json j_object = js[i];
         for (auto& [key, val] : j_object.items()){
       if(key=="PoolRef" && val=="String4k")
         return true;      
         }
       }
       return false;
     }     
     return (specString.find("PoolRef:String4k") != std::string::npos || specString.find("PoolRef: String4k") != std::string::npos ||
                    specString.find("PoolRef : String4k") != std::string::npos); 
   }

quote()

std::string IOVDbNamespace::quote

(

const std::string &

sentence

)

Enclose a string in ".

Definition at line 85 of file IOVDbStringFunctions.cxx.

                                   {
    std::string out;
    out.reserve(sentence.size() + 2);
    out += '\"';
    out += sentence;
    out += '\"';
    return out;
  }

replaceNULL()

std::string IOVDbNamespace::replaceNULL

(

const std::string &

possibleNULL

)

replace an uppercase NULL (such as returned by oracle) in string with a lowercase null (such as used in JSON)

Definition at line 126 of file IOVDbStringFunctions.cxx.

                                             {
    const std::string &original{possibleNULL};
    const std::string regex=R"delim( NULL)delim";
    const std::regex nullre(regex);
    return std::regex_replace(original,nullre," null");
  }

replaceServiceType71()

bool IOVDbNamespace::replaceServiceType71

(

std::string &

addrHeader

)

Definition at line 211 of file IOVDbStringFunctions.cxx.

                                              {
    const std::size_t svcType = addrHeader.find("service_type=\"71\"");
    if (svcType != std::string::npos) {
      addrHeader.replace(svcType, 17, "service_type=\"256\"");
      return true;
    }
    return false;
  }

resolveUsingTagInfo()

std::string IOVDbNamespace::resolveUsingTagInfo	(	const std::string &	tag,
		const ITagInfoMgr *	tagInfoMgr )

Definition at line 54 of file TagFunctions.cxx.

                                                                           {
    // tag an input tag of form TagInfo{Major|Minor}/<tag> or 
    // TagInfo(Major|Minor}/<prefix>/<tag>
    // and resolve to value of TagInfo object tag <tag>
    // with optional prefix
    // <prefix>DEFAULT tags are no longer returned
    // return true for successful resolution
    std::string result="";
    enum ResultIndices{WHOLETAG, MAJMIN, PATH1, PATH2, SIZEWITHPREFIX};
    auto results=IOVDbNamespace::parseMagicTag(tag);
    if (results.empty()) {
       return result;
    }  
    const auto & [prefix, target] = IOVDbNamespace::tag2PrefixTarget(results);
    // try to get the Tag value
    if( tagInfoMgr ) {
      result= IOVDbNamespace::getTagInfo(tag, tagInfoMgr);
    }
    // if nothing found, try to get GeoAtlas directly from GeoModelSvc
    if (result.empty() and target=="GeoAtlas") {
      result=prefix+IOVDbNamespace::getGeoAtlasVersion();
    }
    if (not result.empty()) {
      std::string::size_type rstrip{};
      //number of characters to strip from tag end
      if (results[MAJMIN] == "Major") rstrip=6;
      if (results[MAJMIN] == "Minor") rstrip=3;
      // check if characters need to be stripped from end of tag
      if (rstrip>0 && tag.size()>rstrip) result.erase(result.size()-rstrip);
    } else {
      throw std::runtime_error("Could not resolve TagInfo tag " + target );
    }
    return result;
  }

runLumiFromIovTime()

std::pair< unsigned long long, unsigned long long > IOVDbNamespace::runLumiFromIovTime

(

const unsigned long long

iovTime

)

Return a [run,lumi] pair from an IOV time.

Definition at line 108 of file IOVDbCoolFunctions.cxx.

                                                      {
    return std::pair<unsigned long long, unsigned long long>{iovTime>>32, iovTime&0xFFFFFFFF};
  }

sanitiseCrestTag()

std::string IOVDbNamespace::sanitiseCrestTag

(

const std::string &

fname

)

return valid CREST tag name from folder name

Definition at line 121 of file IOVDbStringFunctions.cxx.

                                           {
    return sanitiseFilename(fname);
  }

sanitiseFilename()

std::string IOVDbNamespace::sanitiseFilename

(

const std::string &

fname

)

Replace the '/' of a file path with '^'.

Definition at line 110 of file IOVDbStringFunctions.cxx.

                                           {
    std::string newName{fname};
    auto oldEnd = newName.end();
    auto newEnd = std::remove(newName.begin(), oldEnd, '/');
    //keep this line for reference
    //std::replace(newName.begin(), newName.end(), '/', '^');
    newName.erase(newEnd, newName.end());
    return newName;
  }

sanitiseJsonString()

std::string IOVDbNamespace::sanitiseJsonString

(

const std::string &

dataString

)

Sanitise json string, escaping raw carriage returns.

Definition at line 52 of file IOVDbStringFunctions.cxx.

                                                  {
    const std::string regex="\n";
    const std::regex lf(regex);
    return std::regex_replace(dataString,lf,"\\n");
  }

sanitiseXml()

std::string IOVDbNamespace::sanitiseXml

(

const std::string &

pseudoXmlString

)

for use when converting cool folder description JSON

Definition at line 134 of file IOVDbStringFunctions.cxx.

                                                {
    std::string result;
    unsigned int strSize(pseudoXmlString.size());
    unsigned int bufsize(strSize*1.1);
    result.reserve(bufsize);
    for(size_t pos = 0; pos != strSize; ++pos) {
      switch(pseudoXmlString[pos]) {
        case '\"': result.append("\\\"");      break;
 
        default:   result.append(&pseudoXmlString[pos], 1); break;
      }
    }
    return result;
  }

spaceStrip()

std::string IOVDbNamespace::spaceStrip

(

const std::string &

input

)

Trim leading and trailing spaces,return a new trimmed string.

Definition at line 11 of file IOVDbStringFunctions.cxx.

                                      {
    // return the input string stripped of leading/trailing spaces
    std::string::size_type idx1=input.find_first_not_of(" \n\r\t");
    std::string::size_type idx2=input.find_last_not_of(" \n\r\t");
    if (idx1==std::string::npos || idx2==std::string::npos) {
      return "";
    } else {
      return std::string(input.substr(idx1,1+idx2-idx1));
    }
  }

tag2PrefixTarget()

std::pair< std::string, std::string > IOVDbNamespace::tag2PrefixTarget

(

const std::vector< std::string > &

parseResult

)

Takes a vector<string> containing {"<fulltag>", "Major|Minor", "<prefix>", "<tag>"} and returns a pair of {"<prefix>", "<tag>"}.

Note "<prefix>" is optional in the input and if missing will be an empty string on output.

Definition at line 197 of file IOVDbStringFunctions.cxx.

                                                                {
    std::pair<std::string, std::string> pair;
    std::string &prefix{pair.first};
    std::string &target{pair.second};
    if (tagParseResults.size() == 4){ //4 is the size of result set if there is a prefix
      prefix = tagParseResults[2]; //index of first path
      target = tagParseResults[3]; //index of second path
    } else {
      target = tagParseResults[2];
    }
    return pair;
  }

tagIsMagic()

bool IOVDbNamespace::tagIsMagic

(

const std::string &

candidateTag

)

Resolve magic tag.

Definition at line 156 of file IOVDbStringFunctions.cxx.

                                            {
    const std::string regex=R"delim(TagInfo(Major|Minor)/.*)delim";
    const std::regex magicx(regex);
    return std::regex_match(candidateTag, magicx);
  }

typeSizeIsKnown()

bool IOVDbNamespace::typeSizeIsKnown

(

const coral::Attribute &

attribute

)

Return a bool indicating whether the size of a given Attribute can be determined.

Definition at line 67 of file IOVDbCoolFunctions.cxx.

                                                   {
    return (sizeFunctions.find(std::type_index(attribute.specification().type())) != sizeFunctions.end());
  }

unescapeBackslash()

std::string IOVDbNamespace::unescapeBackslash

(

const std::string &

original

)

Definition at line 102 of file IOVDbStringFunctions.cxx.

                                               {
    const std::string regex=R"delim([\\]+)delim";
    const std::string replace=R"delim(\)delim";
    const std::regex re(regex);
    return std::regex_replace(original, re,replace);
  }

unescapeQuotes()

std::string IOVDbNamespace::unescapeQuotes

(

const std::string &

original

)

Definition at line 95 of file IOVDbStringFunctions.cxx.

                                            {
    const std::string regex=R"delim(\\")delim";
    std::regex re(regex);
    return std::regex_replace(original, re,"\"");
  }

Variable Documentation

ALL_LUMI_BLOCKS

unsigned long long IOVDbNamespace::ALL_LUMI_BLOCKS {0xFFFFFFFF}

constexpr

All the lumi blocks in one run.

Definition at line 36 of file IOVDbCoolFunctions.h.

{0xFFFFFFFF};

s_closeJson

const std::string IOVDbNamespace::s_closeJson = "}"

inlinestatic

json close tag, '}'

Definition at line 29 of file IOVDbJsonStringFunctions.h.

s_delimiterJson

const std::string IOVDbNamespace::s_delimiterJson = ", "

inlinestatic

json standard delimiter ', '

Definition at line 32 of file IOVDbJsonStringFunctions.h.

s_openJson

const std::string IOVDbNamespace::s_openJson = "{"

inlinestatic

json open tag, '{'

Definition at line 26 of file IOVDbJsonStringFunctions.h.