IOVDbNamespace Namespace Reference

Classes
class	Cool2Json
class	FMDReadLock
struct	FolderAddressSpec
class	IovStore
class	ReadFromFileMetaData
class	SafeReadFromFileMetaData
struct	TimeStampCorrectionResult
	Result of correctTimeStampElement(): the (possibly corrected) description string, what happened to its <timeStamp> element, and the token the element held before any change (empty when Inserted). More...

Enumerations
enum	FolderType {   UNKNOWN =-1 , AttrList =0 , AttrListColl , PoolRef ,   PoolRefColl , CoraCool , CoolVector , JSON ,   NUM_FOLDER_TYPES }
enum class	TimeStampCorrection { Unchanged , Corrected , Inserted }
	Outcome of correctTimeStampElement(): whether the description's timeStamp> element already matched the given token, was replaced because it disagreed, or was inserted because it was missing. More...

Functions
std::string	base64Encode (const coral::Blob &blob)
coral::Blob	base64Decode (const std::string &base64String)
std::ostream &	operator<< (std::ostream &o, const Cool2Json &c)
bool	resolveFolderAddress (MsgStream &log, const IOVDbParser &parsedDescription, const std::string &folderName, bool jokey, const std::string &currentKey, IClassIDSvc *clidSvc, FolderAddressSpec &result)
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	stripIovBounds (const std::string &jsonjson)
	Remove the "since"/"until" members from a dumpChannelsAsJson channel dump, leaving only payload content.
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)
std::string	chaiConnectString (const std::string &endpoint)
	Map an IOVDb.CrestServer-style endpoint (an HTTP(S) URL, a filesystem path, or either already prefixed "crest:"/"crest_fs:") to a CHAI connection string.
TimeStampCorrectionResult	correctTimeStampElement (const std::string &description, const std::string &token)
	Force a folder/node description's <timeStamp> element to the given token ("time" or "run-lumi"), inserting the element if the description has none.
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
   };

TimeStampCorrection

enum class IOVDbNamespace::TimeStampCorrection

strong

Outcome of correctTimeStampElement(): whether the description's timeStamp> element already matched the given token, was replaced because it disagreed, or was inserted because it was missing.

Enumerator
Unchanged
Corrected
Inserted

Definition at line 162 of file IOVDbStringFunctions.h.

{ Unchanged, Corrected, Inserted };

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);
  }

chaiConnectString()

std::string IOVDbNamespace::chaiConnectString

(

const std::string &

endpoint

)

Map an IOVDb.CrestServer-style endpoint (an HTTP(S) URL, a filesystem path, or either already prefixed "crest:"/"crest_fs:") to a CHAI connection string.

Appends /api-v6.0 to an HTTP(S) URL with no API-version path segment.

Definition at line 221 of file IOVDbStringFunctions.cxx.

                                               {
    static const std::string httpPrefix{"http://"};
    static const std::string httpsPrefix{"https://"};
    static const std::string fsPrefix{"crest_fs:"};
    static const std::string serverPrefix{"crest:"};
    // An explicit crest_fs: scheme is taken as written, so a directory name
    // that looks like a host (conditions.db) is never turned into a server
    if (endpoint.starts_with(fsPrefix)) {
      return endpoint;
    }
    std::string ep = endpoint;
    if (ep.starts_with(serverPrefix)) {
      ep = ep.substr(serverPrefix.size());
    }
    // A bare host name (no scheme, no path separator, a dot or a port)
    // is a server, not a directory. Default it to https, matching
    // IOVDbAutoCfgFlags.getCrestServer, or CHAI treats it as a
    // nonexistent filesystem path.
    const bool bareHost = (ep.find('/') == std::string::npos)
                       && (ep.find('.') != std::string::npos || ep.find(':') != std::string::npos);
    if (bareHost) {
      ep = httpsPrefix + ep;
    }
    if (ep.starts_with(httpPrefix) || ep.starts_with(httpsPrefix)) {
      while (ep.ends_with('/')) {
        ep.pop_back();
      }
      // The API version is a path segment, so a host name containing
      // "api-v" does not count
      if (ep.find("/api-v") == std::string::npos) {
        ep += "/api-v6.0";
      }
      return "crest:" + ep;
    }
    return "crest_fs:" + ep;
  }

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;
  }

correctTimeStampElement()

TimeStampCorrectionResult IOVDbNamespace::correctTimeStampElement	(	const std::string &	description,
		const std::string &	token )

Force a folder/node description's <timeStamp> element to the given token ("time" or "run-lumi"), inserting the element if the description has none.

Definition at line 259 of file IOVDbStringFunctions.cxx.

                                                                                 {
    const std::string regex=R"delim(<timeStamp>\s*([^<\s]*)\s*</timeStamp>)delim";
    const std::regex re(regex);
    std::smatch tsMatch;
    const std::string newElement = "<timeStamp>" + token + "</timeStamp>";
    if (!std::regex_search(description, tsMatch, re)) {
      return {newElement + description, TimeStampCorrection::Inserted, {}};
    }
    if (tsMatch[1] == token) {
      return {description, TimeStampCorrection::Unchanged, tsMatch[1]};
    }
    std::string corrected{description};
    corrected.replace(tsMatch.position(0), tsMatch.length(0), newElement);
    return {corrected, TimeStampCorrection::Corrected, tsMatch[1]};
  }

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;
  }

resolveFolderAddress()

bool IOVDbNamespace::resolveFolderAddress	(	MsgStream &	log,
		const IOVDbParser &	parsedDescription,
		const std::string &	folderName,
		bool	jokey,
		const std::string &	currentKey,
		IClassIDSvc *	clidSvc,
		FolderAddressSpec &	result )

Definition at line 15 of file FolderAddressResolver.cxx.

                                                     {
  // Check for key, giving a different key to the foldername
  result.key = currentKey;
  if (auto newkey = parsedDescription.key(); not newkey.empty() and not jokey) {
    log << MSG::DEBUG << "Key for folder " << folderName << " set to " << newkey
        << " from description string" << endmsg;
    result.key = std::move(newkey);
  }
 
  // Check for <named/>
  result.named = parsedDescription.named();
 
  // Get addressHeader
  if (auto newAddrHeader = parsedDescription.addressHeader(); not newAddrHeader.empty()) {
    IOVDbNamespace::replaceServiceType71(newAddrHeader);
    result.addrheader = std::move(newAddrHeader);
  }
 
  // Get clid, if it exists (set to zero otherwise)
  result.clid = parsedDescription.classId(log);
  // Decode the typeName
  if (!parsedDescription.getKey("typeName", "", result.typeName)) {
    log << MSG::ERROR << "Primary type name is empty" << endmsg;
    return false;
  }
  bool gotCLID = (result.clid != 0);
 
  log << MSG::DEBUG << "Got folder typename " << result.typeName << endmsg;
 
  // Only consult the service when the description supplied no clid. It may
  // legitimately be null.
  if (!gotCLID && clidSvc) {
    if (StatusCode::SUCCESS == clidSvc->getIDOfTypeName(result.typeName, result.clid)) {
      gotCLID = true;
    }
  }
 
  if (!gotCLID) {
    log << MSG::ERROR << "Could not get clid for typeName: " << result.typeName << endmsg;
    return false;
  }
 
  log << MSG::DEBUG << "Got folder typename " << result.typeName
      << " with CLID " << result.clid << endmsg;
  return true;
}

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));
    }
  }

stripIovBounds()

std::string IOVDbNamespace::stripIovBounds

(

const std::string &

json

)

Remove the "since"/"until" members from a dumpChannelsAsJson channel dump, leaving only payload content.

CREST shares one range across every channel while COOL tracks one per channel, so bounds can differ where payloads agree.

Definition at line 49 of file IOVDbJsonStringFunctions.cxx.

                                       {
    // Tolerates any whitespace around the separators, so a delimiter change
    // cannot turn this into a no-op that reports every folder as differing.
    static const std::regex boundsRe(R"("since"\s*:\s*-?[0-9]+\s*,\s*"until"\s*:\s*-?[0-9]+\s*,\s*)");
    return std::regex_replace(json, boundsRe, "");
  }

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 35 of file IOVDbJsonStringFunctions.h.

s_delimiterJson

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

inlinestatic

json standard delimiter ', '

Definition at line 38 of file IOVDbJsonStringFunctions.h.

s_openJson

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

inlinestatic

json open tag, '{'

Definition at line 32 of file IOVDbJsonStringFunctions.h.