IOVDbNamespace::Json2Cool Class Reference

Produces cool objects from their JSON representation, storing them in a 'BasicFolder'. More...

#include <Json2Cool.h>

Collaboration diagram for IOVDbNamespace::Json2Cool:

Public Member Functions
	Json2Cool (std::istream &stream, BasicFolder &b, const std::string &specString, const IovStore::Iov_t *iov=nullptr)
	~Json2Cool ()=default

Static Public Member Functions
static cool::Record	createAttributeList (cool::RecordSpecification *pSpec, const nlohmann::json &j)
static cool::RecordSpecification *	parsePayloadSpec (const std::string &stringSpecification)

Private Member Functions
void	init (std::istream &stream, const std::string &specString, const IovStore::Iov_t *iov)

Private Attributes
cool::RecordSpecification *	m_sharedSpec = nullptr
BasicFolder &	m_basicFolder

Detailed Description

Produces cool objects from their JSON representation, storing them in a 'BasicFolder'.

Definition at line 28 of file Json2Cool.h.

Constructor & Destructor Documentation

Json2Cool()

IOVDbNamespace::Json2Cool::Json2Cool	(	std::istream &	stream,
		BasicFolder &	b,
		const std::string &	specString,
		const IovStore::Iov_t *	iov = nullptr
	)

Definition at line 55 of file Json2Cool.cxx.

                                                                                                                  :m_basicFolder(b){
  init(stream, specString, iov);
  }

~Json2Cool()

IOVDbNamespace::Json2Cool::~Json2Cool ( )

default

Member Function Documentation

createAttributeList()

cool::Record IOVDbNamespace::Json2Cool::createAttributeList ( cool::RecordSpecification *  pSpec, const nlohmann::json &  j  )

static

Definition at line 150 of file Json2Cool.cxx.

                                                                                       {
    cool::Record a(*pSpec);
    unsigned int s=a.size();
    
    json::const_iterator it = j.begin();
    for (unsigned int i(0);i!=s;++i){
      auto & f=a[i];
      if (it == j.end()){
        continue;
      }
      const auto  thisVal = it.value();
      ++it;
      
      try{
        // cool::Record does not provide non-const access to AttributeList.
        // But this is safe because we are filling a local instance.
        auto & att ATLAS_THREAD_SAFE = const_cast<coral::Attribute&>(a.attributeList()[i]);
        if (thisVal.is_null()){
          att.setNull();
          continue;
        }
    cool::StorageType::TypeId typespec = f.storageType().id();
        std::string strVal = to_string(thisVal);
        if(strVal.size()>2&& strVal[0]=='"'&& strVal[strVal.size()-1]=='"')
          strVal=strVal.substr(1,strVal.size()-2);
 
        if((strVal.compare("NULL")==0||strVal.compare("null")==0)&&
      (typespec==StorageType::Bool || typespec==StorageType::Int16 || typespec==StorageType::UInt16
          || typespec==StorageType::Int32 || typespec==StorageType::UInt32
          || typespec==StorageType::Int64 || typespec==StorageType::UInt63
          || typespec==StorageType::Float || typespec==StorageType::Double)){
          att.setNull();
          continue;
        }
        switch (typespec) {
    case StorageType::Bool:
      {
        const bool newVal=(strVal == "true");
        att.setValue<bool>(newVal);
        break;
      }
    case StorageType::UChar:
      {
        const unsigned char newVal=std::stoul(strVal);
        att.setValue<unsigned char>(newVal);
        break;
      }
    case StorageType::Int16:
      {
        const short newVal=std::stol(strVal);
        att.setValue<short>(newVal);
        break;
      }
    case StorageType::UInt16:
      {
        const unsigned short newVal=std::stoul(strVal);
        att.setValue<unsigned short>(newVal);
        break;
      }
    case StorageType::Int32:
      {
        const int newVal=std::stoi(strVal);
        att.setValue<int>(newVal);
        break;
      }
    case StorageType::UInt32:
      {
        const unsigned int newVal=std::stoull(strVal);
        att.setValue<unsigned int>(newVal);
        break;
      }
    case StorageType::UInt63:
      {
        const  unsigned long long newVal=std::stoull(strVal);
        att.setValue<unsigned long long>(newVal);
        break;
      }
    case StorageType::Int64:
      {
        const  long long newVal=std::stoll(strVal);
        att.setValue< long long>(newVal);
        break;
      }
    case StorageType::Float:
      {
        const  float newVal=std::stof(strVal);
        att.setValue<float>(newVal);
        break;
      }
    case StorageType::Double:
      {
        const  double newVal=std::stod(strVal);
        att.setValue<double>(newVal);
        break;
      }
    case StorageType::String255:
    case StorageType::String4k:
    case StorageType::String64k:
    case StorageType::String16M:
    case StorageType::String128M:
      {
        att.setValue<std::string>(thisVal.get<std::string>());
        break;
      }
    case StorageType::Blob128M:
    case StorageType::Blob16M:
    case StorageType::Blob64k:
      {
        auto blob = base64Decode(strVal);
        att.setValue<coral::Blob>(blob);
        break;
      }
    default:
      {
        std::string typeName{};
        for (auto& [key,val] : typeCorrespondance) {
          if(val==typespec) {
        typeName = key;
        break;
          }
        }
        if(typeName.empty()) {
          typeName = "Unexpected Type";
        }
        std::string errorMessage("UNTREATED TYPE! " + typeName);
        std::cerr << errorMessage << std::endl;
        throw std::runtime_error(errorMessage);
        break;
      }
    }
      } 
      catch (json::exception& e){
        std::cerr << e.what() << std::endl;
    throw std::runtime_error(e.what());
      }
    }
    return a;
  }

init()

void IOVDbNamespace::Json2Cool::init ( std::istream &  stream, const std::string &  specString, const IovStore::Iov_t *  iov  )

private

Definition at line 60 of file Json2Cool.cxx.

                                                                                       {
    if (not s.good() or s.eof()){
      const std::string msg("Json2Cool constructor; Input is invalid and could not be opened.");
      throw std::runtime_error(msg);
    } else {
      json j;
      try{
        s>>j; //read into json
      }catch (const std::exception& e) {
        std::cout<<"ERROR AT LINE "<<__LINE__<<" of "<<__FILE__<<std::endl;
        std::cout<<e.what()<<std::endl; //typically a parsing error
      }
      m_sharedSpec = parsePayloadSpec(specString);
      const auto & payload=(j.contains("data")) ? j["data"] : j;
      if(iov) {
    m_basicFolder.setIov(*iov);
      }
      else {
    m_basicFolder.setIov(IovStore::Iov_t(0, cool::ValidityKeyMax));
      }
      if (m_basicFolder.isVectorPayload()){
        for (json::const_iterator k=payload.begin();k!=payload.end();++k){ //k are {"0":}
          const json& f=k.value(); //channel id
          const std::string& ks=k.key();
          const long long key=std::stoll(ks);
          std::vector<coral::AttributeList> tempVector;//can optimise this by pre constructing it and using 'clear'
          for (json::const_iterator i=f.begin();i!=f.end();++i){
            const json& arrayElem=i.value();
            auto r=createAttributeList(m_sharedSpec,arrayElem);
            const auto & attList=r.attributeList();
            tempVector.push_back(attList);
          }
          m_basicFolder.addChannelPayload(key, tempVector);
          //add payload with channelId here
        }
      } else {
        for (json::const_iterator i=payload.begin();i!=payload.end();++i){
          const json& f=i.value();
          const std::string& ks=i.key();
          const long long key=std::stoll(ks);
          auto r=createAttributeList(m_sharedSpec,f);
          const auto & attList=r.attributeList();
          m_basicFolder.addChannelPayload(key, attList);
        }
      }
    }
  }

parsePayloadSpec()

cool::RecordSpecification * IOVDbNamespace::Json2Cool::parsePayloadSpec ( const std::string &  stringSpecification )

static

Definition at line 111 of file Json2Cool.cxx.

                                                                  {
    if (stringSpecification.empty()) return nullptr;
    auto *spec = new cool::RecordSpecification();
 
    std::string inputObj=stringSpecification;
    nlohmann::json nl=nlohmann::json::parse(stringSpecification);
    if(nl.is_array()){
      for (unsigned int i = 0; i < nl.size(); i++)
      {
        if(nl[i].size()>0){
      auto it = nl[i].items().begin();
      std::string n((*it).key());
          std::string t((*it).value());
          spec->extend(n, typeCorrespondance.find(t)->second);    
    }   
      }
      return spec;
    }
 
    std::string input(stringSpecification);
    
    std::string regex=R"delim(([^\s,:]*):\s?([^\s,]*),?)delim";
    boost::regex expression(regex);
    boost::smatch what;
    
    bool match=boost::regex_search(input, what, expression);
    while (match){
      std::string n(what[1]);
      std::string t(what[2]);
      //todo: need to catch error if type not found, also
      spec->extend(n, typeCorrespondance.find(t)->second);
      input = what.suffix();
      match=boost::regex_search(input, what, expression);
      
    }
    return spec;
  }

Member Data Documentation

m_basicFolder

BasicFolder& IOVDbNamespace::Json2Cool::m_basicFolder

private

Definition at line 43 of file Json2Cool.h.

m_sharedSpec

cool::RecordSpecification* IOVDbNamespace::Json2Cool::m_sharedSpec = nullptr

private

Definition at line 42 of file Json2Cool.h.

---

The documentation for this class was generated from the following files:

• Json2Cool.h
• Json2Cool.cxx